Problems with ASP Today

When Active Server Pages (ASP) was first introduced almost five years ago, it was seen as an answer to the awkward techniques used at that time for creating dynamic content on the Web. At the time Common Gateway Interface programs or proprietary server plug-ins were the way that most of the Web's dynamic content was created. With the release of ASP 1.0, Microsoft changed all that. ASP 1.0 provided a flexible robust scripting architecture that enabled developers to rapidly create dynamic Web applications. Developers could write in VBScript or JScript and Microsoft provided a number of services to make development easy. At the time, it was just what developers needed. As Web development matured several shortcomings of the platform became evident, and persist until today.

Separation of Code and Design

As the Web grew in popularity in the early 90s, developers experienced three distinct waves of development paradigms . In the first wave, Web developers created static HTML documents and linked them together. This was the era of the "brochure" Web site and was more about looks than anything else. The second wave brought the concept of dynamic content to the fore. Developers started creating registration forms and various small pieces of functionality and adding them into existing Web sites. The third wave was when the first and second waves came together. Web sites were being designed from the ground up to be interactive; they were treated more like an application and less like a magazine with a subscription card in it. In most instances this type of interactive page design created a development paradigm that went like so:

• Designers created page mockups in HTML.

• Developers added code to the pages.

• When designers needed to change their design, they copied and pasted the existing code into the new page, butchering it and destroying its functionality.

The severity of this problem typically depended on the size of the site, the smarts of the designers, and the techniques that developers used to guard against this mangling.

With the release of Visual Studio 6 in September 1998, it was clear that Microsoft recognized this burgeoning problem and attempted to resolve it with a new feature in Visual Basic 6, Web Classes. Web Classes made an attempt to separate the design of a page from the code that interacted with it. It enabled this separation by using an HTML template and providing a facility for doing tag replacement in the template. There were a number of problems with Web Classes. Although a great idea, they suffered from two main issues. First, the Web Classes were implemented entirely in Visual Basic, which required traditional ASP developers to shift their thinking patterns for creating applications. Second, Microsoft had scalability issues related to the threading models of ASP and Visual Basic. Because of the previously stated reasons and many other smaller ones, Web Classes never really gained any traction among developers.

Scripting Language Based

When ASP 1.0 was first released, the fact that all development was done using scripting languages was a big plus. It meant that developers didn't have to go through a painful restart/compile process that they might have been accustomed to with CGI or ISAPI style applications. As applications grew larger, numbers of users increased and developers were using ASP for increasingly difficult problems. The fact that all code was interpreted became a potential performance bottleneck. When using VBScript there was limited support for error handling. Many developers sidestepped this issue by moving code into compiled COM objects. While this move solved some of the performance problems it created new ones in deployment and scalability.

State Management

One of the most frustrating aspects that new Web developers faced early was dealing with the stateless nature of Web development. With ASP 1.0, Microsoft introduced the concept of a Session object, which was designed to make associating state with a particular user easy. This addition was arguably one of the most compelling features of ASP 1.0. Scalability and reliability started to become important as developers began creating larger applications. To address this need, developers started deploying their applications to Web farms. Web farms use multiple servers and spread the request for pages across them somewhat equally. This makes for a great scalability story unless the developer is using that cool Session object. This object is specific to a particular machine in a Web farm and will not work if a user gets bounced to another server. So, an application that was deployed to a Web farm could not use the Session object.