History of Asp.net

History of Asp.net

Before organizations were even thinking about developing applications for the Internet, much of

the application development focused on thick desktop applications. These thick-client applications

were used for everything from home computing and gaming to office productivity and more. No

end was in sight for the popularity of this application model.

During that time, Microsoft developed its thick-client applications using mainly Visual Basic (VB).

Visual Basic was not only a programming language; it was tied to an IDE that allowed for easy

thick-client application development. In the Visual Basic model, developers could drop controls

onto a form, set properties for these controls, and provide code behind them to manipulate the

events of the control. For example, when an end user clicked a button on one of the Visual Basic

forms, the code behind the form handled the event.

Then, in the mid-1990s, the Internet arrived on the scene. Microsoft was unable to move the Visual

Basic model to the development of Internet-based applications. The Internet definitely had a lot of

power, and right away the problems facing the thick-client application model were revealed.

Internet-based applications created a single instance of the application that everyone could access.

Having one instance of an application meant that when the application was upgraded or patched,

the changes made to this single instance were immediately available to each and every user visiting the

application through a browser.

To participate in the Web application world, Microsoft developed Active Server Pages (ASP). ASP was a

quick and easy way to develop Web pages. ASP pages consisted of a single page that contained a mix of

markup and languages. The power of ASP was that you could include VBScript or JScript code instruc-

tions in the page executed on the Web server before the page was sent to the end user’s Web browser.

This was an easy way to create dynamic Web pages customized based on parameters dictated by the

developer.

ASP used script between brackets and percentage signs—<% %>—to control server-side behaviors. A

developer could then build an ASP page by starting with a set of static HTML. Any dynamic element

needed by the page was defined using a scripting language (such as VBScript or JScript). When a user

requested the page from the server by using a browser, the asp.dll (an ISAPI application that provided

a bridge between the scripting language and the Web server) would take hold of the page and define all

the dynamic aspects of the page on-the-fly based on the programming logic specified in the script. After

all the dynamic aspects of the page were defined, the result was an HTML page output to the browser of

the requesting client.

As the Web application model developed, more and more languages mixed in with the static HTML to

help manipulate the behavior and look of the output page. Over time, such a large number of languages,

scripts, and plain text could be placed in a typical ASP page that developers began to refer to pages that

utilized these features as spaghetti code. For example, it was quite possible to have a page that used HTML,

VBScript, JavaScript, Cascading Style Sheets, T-SQL, and more. In certain instances, it became a manage-

ability nightmare.

ASP evolved and new versions were released. ASP 2.0 and 3.0 were popular because the technology

made it relatively straightforward and easy to create Web pages. Their popularity was enhanced because

they appeared in the late ’90s, just as the dotcom era was born. During this time, a mountain of new Web

pages and portals were developed, and ASP was one of the leading technologies individuals and compa-

nies used to build them. Even today, you can still find a lot of .asp pages on the Internet—including

some of Microsoft’s own Web pages.

But even at the time of the final release of Active Server Pages in late 1998, Microsoft employees Marc

Anders and Scott Guthrie had other ideas. Their ideas generated what they called XSP (an abbreviation

with no meaning)—a new way of creating Web applications in an object-oriented manner instead of the

procedural manner of ASP 3.0. They showed their idea to many different groups within Microsoft, and

were well received. In the summer of 2000, the beta of what was then called ASP+ was released at

Microsoft’s Professional Developers Conference. The attendees eagerly started working with it. When

the technology became available (with the final release of the .NET Framework 1.0), it was renamed

ASP.NET—receiving the .NET moniker that most of Microsoft’s new products were receiving at that

time.

Before the introduction of .NET, the model that classic ASP provided and what developed in Visual Basic

were so different that few VB developers also developed Web applications—and few Web application

developers also developed the thick-client applications of the VB world. There was a great divide.

ASP.NET bridged this gap. ASP.NET brought a Visual Basic–style eventing model to Web application

development, providing much-needed state management techniques over stateless HTTP. Its model is

much like the earlier Visual Basic model in that a developer can drag and drop a control onto a design

surface or form, manipulate the control’s properties, and even work with the code behind these controls

to act on certain events that occur during their lifecycles. What ASP.NET created is really the best of both

models, as you will see throughout this book.

I know you’ll enjoy working with this latest release of ASP.NET—2.0. Nothing is better than getting

your hands on a new technology and seeing what’s possible. The following section discusses the goals of

ASP.NET 2.0 so you can find out what to expect from this new offering!