ASP: Server-Side Scripts and Dynamic Webpages

Active Server Pages, or ASP, was a scripting environment Microsoft provided for web servers. It allowed pages to combine Hypertext Markup Language (HTML), scripts and server components to generate content when an access request arrived. Both intranets and public websites could use this approach to connect browsing with back-end business processing.

In a developer-conference announcement on November 4, 1996, Microsoft explicitly stated that ASP had previously been called Denali and was planned for release with Internet Information Server 3.0. The December 10 release announcement said IIS 3.0 would be available that week for Windows NT Server 4.0 users to download. The year 1996 therefore marks the transition from announcement and testing to the first formal deliveries; announcement dates should not be treated as the dates when every user actually obtained the software.

References: [1] [2]

ASP was not the story of a single independent language designer. Microsoft's IIS team incorporated script execution into its server product, while outside developers extended its uses through components and examples. George V. Reilly's preserved source-code notes document one participant's contribution: from October 1996 to May 1997, while working at MicroCrafts, a consulting company in Redmond, Washington, he wrote sample ASP components for Microsoft's IIS team.

Most of these components used the Active Template Library, or ATL, a C++ component-development library. Reilly later joined the IIS development team and worked on ASP performance improvements. His preserved examples included ad rotation, browser-capability detection, page counting and simple components in several languages. This experience shows the links among the execution engine, component interfaces, demonstration code and performance work; it does not justify calling Reilly ASP's sole inventor.

References: [3]

Early ASP files could retain ordinary HTML and embed scripts within special delimiters. The default scripting language was VBScript, with supported alternatives including JScript. A 1997 technical book described ASP.DLL as running inside the IIS server process: after a request reached the server, server-side scripts in the page executed first, and their text output combined with static portions to form the returned content.

For example, an illustrative VBScript fragment, “Total: <% Response.Write 3 * 7 %>”, writes the multiplication result into the response, returning “Total: 21”. Response.Write handles output, while the server-side script evaluates the multiplication. The browser receives the result rather than having to interpret that VBScript statement itself. This example demonstrates response generation only and requires neither user input nor a database.

An ASP page therefore needs to be accessed through a correctly configured server. Opening a file directly from disk in a browser is not equivalent to executing server-side scripts. If the page also emits browser-side scripts, those are still processed by the client; the two execution locations should be clearly distinguished.

References: [4] [5]

ASP organized common web operations into built-in objects. Request exposed data sent by the client, such as form fields, query parameters and cookies. Response returned content and could also adjust response headers or issue redirects. Programs did not have to assemble every request and response themselves from the lowest level.

After one visit ended, an application often needed to remember earlier user choices. The Session object could retain data across pages within the same session, releasing it when the session expired or was terminated. Application held application-wide information. Their scopes differed: one user's choices could not carelessly be placed in state shared by all visitors.

This model separated input, output and state through objects, but did not decide business rules for the program. Developers still had to design what happened after session timeout, the scope of shared data and page navigation.

References: [5]

ASP also aimed to connect existing business capabilities to webpages. On October 28, 1996, Microsoft demonstrated a development tool codenamed Internet Studio at the Site Builder Conference in San Jose. Development-tools executive Bob Muglia positioned it as a visual environment linking server processing to enterprise databases. The demonstration was still prerelease and should not be equated with commercial availability.

The announcement listed database-query and design tools, along with access to ODBC databases through data objects. COM components on the server could also supply computational results to pages. The tool shared a project model with FrontPage 97, enabling programmers and webpage authors to collaborate. Page layout, data queries and calls to business components could thereby form a workflow rather than merely require manual changes to static files.

References: [6]

Doyle and Lopes's technical survey placed ASP in the development of scripted templates: many webpages had only a small amount of changing content, so embedding logic in a fixed page lowered the barrier to generating dynamic content. By connecting existing components through COM, ASP also made business programs in Microsoft's server environment easier to provide as web services.

The same study identified limitations: mixing presentation and logic within pages did not automatically solve the organizational problems of large applications, and developers still had to address platform dependence, interpretation overhead and reliability. Later, ASP.NET reorganized web applications using the .NET framework and should not be viewed simply as a renaming of the original scripting environment. Although the two retained some similar object names, technical references explicitly distinguished classic ASP objects from .NET classes.

References: [5] [7]