• Active Server
`Components
`e liS 4 Administration
`e ActiveX Data Objects
`e Transactions
`
`Apple Inc. Exhibit 1020
`
`

`
`• ss
`
`Wrox Professional Guides are a one-to-one
`session with experienced developers who
`want to share their hard won knowledge with
`you. These books are a digest of techniques
`and methods that have been proven in the
`field. You will gain a clear understanding of
`the technology by seeing practical examples
`built for bullet-proof operation. You will be
`able to extend and customize the knowledge
`in this book, giving you a smooth path to
`great programming.
`The Wrox Philosophy
`Our aim is to make you successful by sharing
`with you the knowledge of experienced
`programmers at every stage in your career.
`
`Build your Visual Basic career
`with Wrox
`
`Professional
`ASP
`Techniques
`for
`Webmasters
`
`ASP
`Programmer's
`Reference
`
`Professional
`MTSMSMQ
`with VB
`and ASP
`
`Professional
`ADO RDS
`with ASP
`
`AD02.0
`Programmer's
`llelarenc:e
`
`Instant
`VBScript
`
`Beginning
`ASP 2.0
`
`lnslonl
`Java Script
`
`Source code and support for this book
`available on our web sites at
`hHp://www.wrox.com/
`hHp://www.wrox.co.uk/
`
`Active Server Pages 2.0 is the latest update to Microsoft's server(cid:173)
`based technology which comes free as part of both liS 4.0 and
`Personal Web Server 4.0. It is designed to create dynamically
`generated HTML pages for a World Wide Web site or corporate
`intranet. It's just part of an all-encompassing concept called the
`Active Server environment, which has been developed along with
`Microsoft Windows NT Server, and Microsoft Internet Information
`Server (liS). In this book we show you how Active Server Pages fits
`into the grand scheme of things, and how you can use it to build
`really great web sites and intranet applications.
`
`Anybody and everybody who has responsibility for planning,
`building, or maintaining a web site--on the Internet or a company
`intranet-will find this book invaluable. This book updates and
`expands the knowledge of programmers with an existing knowledge
`of ASP 1.0, and allows anyone with knowledge and experience of
`VBScript or JavaScript and the Internet to learn this exciting server
`side web technology.
`
`What does this book cover?
`• Discovering what Active Server Pages (ASP) is, and what it can do
`• Mastering ASP programming with VBScript and JavaScript
`• Using Active Server Components to make ASP programming easier
`• Using the ActiveX Data Objects technology for database access
`• Understanding client-server programming on the Web
`• Building your own Active Server Components to enhance and
`expand your applications
`• Understanding the risks you face on the Internet and learning how
`to protect your site
`• Case studies (with source code) of real-world applications, showing
`advanced techniques
`• A comprehensive, easy look-up, reference section covering all the
`topics in the book
`
`Apple Inc. Exhibit 1020
`
`

`
`Professional
`Active Server Pages 2.0
`
`Alex Fedorov
`Brian Francis
`Richard Harrison
`Alex Homer
`Shawn Murphy
`Robert Smith
`David Sussman
`Stephen Wood
`
`Wrox Press Ltd.
`
`Apple Inc. Exhibit 1020
`
`

`
`Professional Active Server Pages 2.0
`
`© 1998 Wrox Press
`
`All rights reserved. No part of this book may be reproduced, stored in a retrieval system or transmitted in any
`form or by any means-electronic, electrostatic, mechanical, photocopying, recording or otherwise, without the
`prior written permission of the publisher, except in the case of brief quotations embodied in critical articles or
`reviews.
`
`The author and publisher have made every effort in the preparation of this book to ensure the accuracy of the
`information. However, the information contained in this book is sold without warranty, either express or
`implied. Neither the author, Wrox Press nor its dealers or distributors will be held liable for any damages
`caused or alleged to be caused either directly or indirectly by this book.
`
`wrox
`
`Published by Wrox Press Ltd,
`Arden House, 1102 Warwick Road, Acocks Green, Birmingham B27 6BH, UK.
`Printed in Canada
`10 11 12 13 14 TRI 03 02 01 00 99
`
`ISBN 1 - 861001 - 26 - 6
`
`Apple Inc. Exhibit 1020
`
`

`
`An Introduction to
`Active Server Pages
`
`A tive Server Pages is the latest server-based technology from Microsoft, designed to create interactive
`H~ML pages for a World Wide Web Site, or corporate intranet. It is just part of an all encompassing
`oncept called the Active Platform which has been developed along with Microsoft Windows NT Server,
`~d Microsoft Internet Information Server (liS}. In this book, we start by focusing on what the Active
`Platform is and how the various technologies such as liS 4.0, ASP and MTS (Microsoft Transaction Server)
`fit together. We also look at how you can get hold of ASP, and how to install it together with liS 4.0 or
`Personal Web Server 4.0. Then we'll show how Active Server Pages fits into· the grand scheme of things,
`how it has improved in version 2.0 and how you can use it to build really great Web sites and intranet
`applications.
`
`Who is this Book for?
`This is a Wrox 'Professional' series book, so we won't be wasting your time by trying to teach you
`everything from scratch. We appreciate that most, if not all, of the web page authors and developers who
`take up Active Server Pages will be reasonably familiar with ordinary HTML, basic scripting concepts, and
`the simple constructs of the two main scripting languages, VB Script and JavaScript. So, we're assuming that
`you will know about these basic concepts, and that we won't need to waste time and space by going over
`them. If you need a quick refresher on either scripting language, you'll be able to find comprehensive
`references at the back of this book. If you're already familiar with Active Server Pages and want a guide
`that concentrates on the new features of version 2.0, you won't be disappointed, as there are several
`chapters devoted to things that weren't possible in liS 3.0.
`
`Like all Wrox books, this one is written by programmers, for programmers. It's full of practical techniques
`that you can use to develop your own code. There are also plenty of solid code examples, case studies that
`produce real, practical, applications, and reference material both throughout and at the end of the book.
`This means that you can use it as a primer to learn the new techniques, and as a reference for the future(cid:173)
`as you develop your skills and your Web sites, you can keep coming back to learn more.
`
`What do I need to use this book?
`Most importantly you'll need a copy of Active Server Pages and a web server for your platform (which
`must be either Windows 95 or NT 4.0}. You'll also need a browser (preferably Internet Explorer 4} and a
`web page or text editor such as FrontPage 98 or Notepad.
`
`Both Active Server Pages and a web server for either NT 4.0 or Windows 95 are available as part of the
`NT 4.0 Option Pack which is freely downloadable from Microsoft at
`http://www.microsoft.c om/nt s e rver/ guide / whatisntop. a s p
`
`Apple Inc. Exhibit 1020
`
`

`
`-
`
`PROFESSIONAL
`
`ACTIVE SERVER PAGES
`
`There are two versions of the NT 4.0 Option Pack, one for NT 4.0 and one for Windows 95. liS 4.0 is
`the web server that comes with the version of the Option Pack for NT Server 4.0, while Personal Web
`Server 4.0 is included in the NT 4.0 Option Pack for Windows 95. Both of them include Active Server
`Pages 2.0 as standard, so there'll be no need to download anything extra. However, while ASP can run on
`Personal Web Server, this setup isn't optimal and shouldn't be used for most non-development work. In
`addition you'll also find parts of Transaction Server and Message Queue Server are included within the NT
`4.0 Option Pack.
`
`Nearly all of the examples use Active Server Pages and require an HTTP link to a Web server. You can
`use your own machine as a web server if necessary. As mentioned before, we recommend Windows NT4
`Server or Microsoft Personal Web Server 4.0, but you can use a server from any other supplier that
`implements Active Serve Pages.
`
`You may also wish to develop your pages within a specialist environment, such as Microsoft lnterdev,
`FrontPage 98, or a similar application like HoTMetaL Pro or other Web page creation software, but you'll
`need to edit and write the code by hand most of the time.
`
`Where you'll Find the Sample Code
`Our prominent presence on the Web provides you with assistance and support as you use our books. Our
`Internet-related books (including this one) have a special site that provides examples, and allows you to
`download code to run on your own machine. This is at http: I I rapid. wrox. co. uk. You can also find
`a US based mirror of this site at http: I lwww.rapid.wrox.com. Our main US-based site is at
`http: I lwww.wrox.com, and it provides details of all our books. There is also a mirror site at
`http: I lwww. wrox. co. uk that may be more responsive if you're accessing it from Europe.
`
`Conventions
`We have used a number of different styles of text and layout in the book to help differentiate between the
`different kinds of information. Here are examples of the styles we use and an explanation of what they
`mean:
`
`Advice, hints, or background information comes in this type of font.
`
`Important pieces of information come in boxes like this
`
`Important Words are in a bold type font
`
`Words that appear on the screen in menus like the file or Window are in a similar font to
`the one that you see on screen
`
`Keys that you press on the keyboard, like Ctrl and Enter, are in italics
`Code· has several fonts. If it's a word that we're talking about in the text, for example, when
`discussing the For ••• Next loop, it's in a bold font. If it's a block of code that you can type
`in as a program and run, then it's also in a gray box:
`
`2
`
`Apple Inc. Exhibit 1020
`
`

`
`INTRODUCTION
`
`<STYLE>
`... some VBS cript -
`</STYLE>
`
`Sometimes you'll see code in a mixture of styles, like this:
`
`<HTML>
`<HEAD>
`<TITLE>Cascading Style Sheet Example< / TITLE>
`<STYLE>
`stylel {color: red;
`font-size: 25)
`</STYLE>
`</HEAD>
`
`The code with a white background is code we've already looked at and that we don't wish to
`examine further.
`Also you'll see that code in Professional Active Server Pages is either HTML tags, client side
`script or server side script (ASP). Despite being recommended in the HTML 4.0 standard that
`tags should be specified in lower case, for ease of reading we have chosen to display HTML
`tags in upper case throughout the book and all script in lower case. Server side script is
`surrormded by <% and %> marks. So an example might look like this
`
`<BODY>
`<Hl>This is soma HTML </Hl>
`<SCRXPTLANGUAGE=VBScript>
`ob jl .. "this is some vbscript"
`<% obj2 = "this is some ASP" %>
`</SCRXPT>
`</BODY>
`
`These formats are designed to make sure that you know what it is you're looking at. I hope they make life
`easier.
`
`Tell Us What You Think
`We've worked hard on this book to make it useful. We've tried to understand what you're willing to
`exchange your hard-earned money for, and we've tried to make the book live up to your expectations.
`
`Please let us know what you think about this book. Tell us what we did wrong, and what we did right.
`This isn't just marketing flannel: we really do huddle around the email to find out what you think. If you
`don't believe it, then send us a note. We'll answer, and we'll take whatever you say on board for future
`editions. The easiest way is to use email:
`
`feedback@wrox.com
`
`You can also find more details about Wrox Press on our web site. There, you'll find the code from our
`latest books, sneak previews of forthcoming titles, and information about the authors and editors. You can
`order Wrox titles directly from the site, or find out where your nearest local bookstore with Wrox titles is
`located.
`
`3
`
`Apple Inc. Exhibit 1020
`
`

`
`PROFESSIONAL
`
`ACTIVE SERVER PAGES
`
`Customer Support
`If you find a mistake, please have a look at the errata page for this book on our web site first. Appendix L
`outlines how can you can submit an errata in much greater detail, if you are unsure. The full URL for the
`errata page is:
`
`http://www.wrox.corn/Scripts/Errata.idc?Code=1266
`
`If you can't find an answer there, tell us about the problem and we'll do everything we can to answer
`promptly!
`
`Just send us an email to support@wrox. corn.
`
`or fill in the form on our web site: http: I /www. wrox. corn/Contact. strn
`
`A History Lesson: The Evolution of the Client 1 Server
`Model
`Before we begin this book, we're going to give a quick history lesson on how the present client/server
`model evolved. If you're familiar with this then please feel free to skip to Chapter 1, but if not, then we
`recommend that you read this as we reference the concepts discussed here throughout this book.
`
`Senior management have long recognized that an effective Information Technology strategy is required to
`provide productivity improvements, access to new and enhanced revenue streams, and increased customer
`satisfaction. For many years, businesses have exploited IT in the following three dimensions:
`
`Data Processing-these are typically the core systems that control the fundamental business
`processes in an organization, such as Accounting, Stock Control, Order Processing, Job Tracking,
`etc. Many types of technologies, from large mainframes to client/server architectures have been
`applied to these business critical systems and most of these still have a part to play in today's IT
`infrastructures.
`
`Personal Productivity-the rapid evolution of the PC and Integrated Office suites has forever
`changed the way individual employees work with information and has often changed business
`practices and strategies. These tools have dramatically increased productivity, streamlined
`operations and made IT more cost effective.
`
`GroupWare-the use of communications and collaboration software has enabled both
`organizations and individuals to work in partnership and teams. Such systems can scale to
`thousands of users across the enterprise enabling businesses to redefine their operations for
`further advantage and reduced costs.
`
`However, many of these benefits do not come without cost. Each of these dimensions typically has their
`own infrastructures and businesses have been faced with the complex problem of building 'information
`bridges' between the different systems and applications-building systems that span all dimensions has been
`historically difficult. Furthermore, having multiple different infrastructures results in additional costs for
`software, hardware, support and training.
`
`4
`
`Apple Inc. Exhibit 1020
`
`

`
`INTRODUCTION
`
`Over the years, a series of architectures have been devised in an attempt to· integrate the various
`distributed environments within an organization. Forward-looking businesses now demanded that this
`integration must:
`
`automate the business processes to reduce costs
`
`provide easy access to all the organization's information (with appropriate security of course}
`
`provide new opportunities for marketing advantage
`
`remove barriers across the organization
`
`provide flexibility enabling the business to react quickly to change
`
`We shall see that a distributed computing framework using client/server and Internet technologies provides
`the key to fulfilling these requirements.
`
`5
`
`Apple Inc. Exhibit 1020
`
`

`
`PROFESSIONAL
`
`ACTIVE SERVER PAGES
`
`Client/Server: Moving Towards Decentralisation
`Client/server computing is one of the most dominant paradigms of IT and has developed as the computer
`industry moved from a centralized shared logic based system to a network of workstations and servers.
`Client/server involves providing an application architecture that enables a computerized process to be
`broken up into two or more less complex tasks with a communication mechanism for these sub-processes
`to co-operate. The key notion of breaking up the problem is to provide designated layers of functionality
`that can be written and deployed across multiple machines in an optimized manner.
`
`Typical examples of application layers are:
`
`Presentation logic-handling how the user interacts with the application; usually implemented
`by providing an easy to use graphical user interface (GUI)
`
`Business logic- handling the mechanics (or business rules) of the application
`
`Data access logic-handling the storage and retrieval of data; important that the integrity of
`the data is maintained
`
`The development of separate layers needs careful design and an accurate definition of the distinct
`boundaries to ensure that logic within the different layers is not intertwined. Encapsulating the logic in this
`fashion ensures that future changes can be implemented with minimal impact on the other layers and
`enables both reusability and reliability.
`
`Client/server is regarded as an enabling technology that can implement systems across an organization in a
`modular and flexible manner. It allows for the distribution of applications away from single machines
`located in isolated departments to an implementation across the enterprise. For example, it is now possible
`for one person in customer services to access all corporate systems-gone are the old days of annoying
`transfers between the different representatives in each department.
`
`Many companies have rewritten old applications so they remain cost effective by taking advantage of the
`benefits offered by client/server environments. The investment in client/server systems has been accelerated
`by the rapid advances in hardware technology, the appearance of powerful client/server development tools
`and the decrease in prices of implementing these smaller faster platforms.
`
`As we shall now see, there are many variations to client/server architectures. There is no gTeater decision,
`when implementing such a system, than which of these should be used.
`
`Two-tier client/ server
`The first generation of client/server systems is an evolution of the file sharing applications discussed above.
`With these applications, the central file server is replaced with a specialized relational database
`management system (RDBMS). Such databases can offer high transaction rates at a fraction of the cost
`associated with mainframes. When the client (a workstation application typically using a GUI) needs to act
`upon data, it makes a request via the network to the database server-the database then processes the
`request and returns just the data appropriate the client's needs.
`
`When compared to the file sharing application (which returned the complete file), this client/server
`architecture dramatically reduces network traffic. In addition, today's databases provide many features that
`enable the development of sophisticated multi-user applications-for example, allowing multiple users to
`access and update the same set of data safely.
`
`6
`
`Apple Inc. Exhibit 1020
`
`

`
`INTRODUCTION
`
`ocessing is split between distinct layers-the workstation and the database server-such
`th
`tf
`b ·
`·
`e pr
`Because
`J'
`.
`are referred to as emg two-tier c 1en server.
`architectures
`
`Client - Centric Computing
`The most simple and common implemen~ation of two-
`t ms is to place both the presentation and
`.
`.
`.
`tier sys e
`looic on the client-making the architecture fat
`·
`.,-
`.
`usmess
`b
`client/thin server. Database requests from the clients are
`· ally implemented using the database query and
`~;amming language SQJ.. Th: database request is
`~arried to the database server usmg a remote database
`transport protocol-however the programmer can be
`insulated from such complexi~es by means of database
`middle ware such as Microsoft s Open Database
`Connectivity (ODBC).
`
`Personal
`Computers
`
`Database Server
`
`- - -· -d-at-a-Ra_: _::_:_lo_g_ic_ J LJ
`
`Such systems can be implemented quickly (and thus cheaply) using rapid application development (RAD)
`techniques and are great for small workgroup type environments. Many toolset vendors have implemented
`low-cost development products for creating such applications; examples include Microsoft's Visual Basic,
`Sybase's PowerBuilder and Borland's Delphi.
`
`However, tightly binding the business logic into the fat client can cause some severe problems, including
`the following:
`
`the architecture imposes substantial processing on the client; this means workstations with
`powerful CPUs and large amounts of disk and memory may be required
`
`the database requests can generate large result sets; with a large user base this can cause
`severe network degradation
`
`each workstation session requires a separate database connection; this can drain resources on
`the database server-for example, Microsoft SQJ. Server requires 37K of memory for each user
`connection (and this is much lower than many other RDBMSs)
`
`deploying the business rules on the client can lead to high costs of deployment and support;
`if the logic changes, the effort in updating software on numerous workstations can be
`excessive
`
`In practice, it is found that the performance of such two-tier architectures rapidly deteriorates as networking
`bottlenecks occur when an optimum number of users is exceeded. As a result, it does not provide the
`flexibility or scalability for large-scale applications deployed across the enterprise or Internet.
`
`7
`
`Apple Inc. Exhibit 1020
`
`

`
`PROFESSIONAL
`
`ACTIVE SERVER PAGES
`
`Database Server-Centric Computing
`An alternative implementation is the thin client/fat server approach in which the business logic is pushed
`down to the database server using techniques such as stored procedures, triggers and constraints.
`
`A stored procedure is business logic that is invoked by sending a request to the database server that
`includes the stored procedure name and any parameter values. As with the previous client-centric case, this
`request is transmitted using remote database transport protocols and can be implemented simply using
`database middleware (e.g. ODBC).
`
`A constraint is a restriction placed on a data entered into a
`database. A trigger is a stored procedure that is invoked
`automatically on the Add/Update/Delete of items in a table.
`Both can be used to validate entered data and ensure
`referential integrity or consistency across multiple related
`tables in the database.
`
`Personal
`Computers
`
`Database Server
`
`RDBMS
`e business logic
`e data access logic
`Stored Procedures
`
`Stored procedures enable business rules to be defined and deployed across the enterprise. However, two(cid:173)
`tier database applications can involve high development and maintenance costs since two toolsets are
`required-one for the client and another for the RDBMS stored procedure programming language. The
`proprietary nature of the RDBMS languages usually mean database vendor lock-in and reduces the
`possibilities for flexibility and portability-they also require specialized skills which can impact on costs.
`
`Furthermore, as with the client-centric case, the need for the RDBMS to maintain a separate database
`session for each client workstation severely impacts central server resources. This makes the two-tier
`database server unsuitable for scaling across the enterprise or Internet. Large and complex two-tier
`solutions will nearly always result in failure and leave a lot of egg on the IT managers face!
`
`Two-tier Transaction Processing
`A transaction is a set of independent actions that are grouped together to form a 'single item of work'. The
`use of transactions with databases is important to ensure the following, which are often known by their
`acronym 'ACID':
`
`Atomicity-all updates to a database under a transaction must be either committed or get
`rolled back to their previous state
`
`Consistency-that the database is updated in the correct manner
`
`Isolation-uncommitted transactional results are not seen by other pending transactions
`
`Durability-once a transaction is committed, it will persist even if failures occur
`
`l 8
`
`Apple Inc. Exhibit 1020
`
`

`
`INTRODUCTION
`
`with two-tier client I server architectures is simple. Commands to be processed within a
`.
`Using n:ansactiO;~e bound by calls to functions with the RDBMS-typically these are called 'Begin
`transacti?n ,mu~ 'Commit Transaction'. If a failure is detected, the database can be reverted to its original
`Transacttono:r call-typically 'RollBack Transaction' or 'Abort Transaction'. If a system crash occurs,
`state by .an
`actions can be identified and the integrity of the database restored, when the system
`outstandmg trans
`restarts.
`
`Multi-tier client/ server
`blems we have encountered when discussing two-tier client server architectures, it should be
`I
`.
`h
`From t e pro
`.
`.
`.
`to learn that this approach IS now generally accepted as bemg a poor so utwn other than for
`no surpnse
`small workgroup applications.
`
`on the lessons learnt from the two-tier systems, an increase in application performance and a
`.
`D
`· 1
`·
`1
`·
`I'
`ffi
`b b
`h'
`d b
`th
`·
`rawmg
`t1
`notable reduction in network tra 1c can e een ac 1eve
`y 1mp ementing: an a ternative
`ree-tier c 1en
`server architecture.
`
`Three-tier Computing
`The improved architecture involves inserting an additional middle tier between a thin client and a thin
`server to create three tiers.
`
`Personal
`Computers
`
`Application Server
`
`Database Server
`
`e business logiC
`
`RDBMS
`e data access logic
`Stored Procedures J
`
`The client communicates with the middle tier using standard communications protocols such as TCP /IP.
`The middle tier interfaces with the backend RDBMS using standard database protocols or by means of
`database middleware (thus making the solution independent of the RDBMS). The middle tier provides
`basic message switching and contains the business rules of the application; it is responsible for:
`
`acting upon client requests, applying business logic and invoking database requests
`
`handling the database responses, applying further business logic and generating a client
`response
`
`9
`
`Apple Inc. Exhibit 1020
`
`

`
`I
`
`PROFESSIONAL
`
`ACTIVE SERVER PAGES
`
`Furthermore, this approach does not require a separate database connection for each user; instead many
`users sessions can be funneled into just a few database connections and make considerable savings to the
`precious resources on the database server. This means that 1000 users simultaneously accessing an SQL
`Server system would not require a 37M ( 1000 x 37K) overhead of memory.
`
`By creating three tiers, we have now completely partitioned the presentation logic, the business logic and
`the data access logic. One advantage is that any of the tiers can be enhanced or replaced without affecting
`the other tiers. For example, we can easily enhance a system to support new delivery channels. Let's
`consider a customers services based upon a three tier client/server solution. Now suppose that business
`reasons dictate that an interactive voice service is required so that a customer can access the system
`directly from their own telephone using speech recognition and text to speech play-back. Whereas a two(cid:173)
`tier solution would need major surgery, the three-tier solution would only require the development of a
`new user interface (i.e. the voice handling) and could use the existing layers that contained the business
`logic and data access logic.
`
`Personal
`Computers
`
`l
`
`Database Server
`
`Vorce
`Response
`Unit
`
`Appltcation Server
`
`e business logic
`
`It is possible to provide both the business logic and database on the same platform-and in many cases this
`can provide an optimum solution. However, for it to be recognized as three-tier, distinct boundaries or
`interfaces must exist between the two layers to ensure the advantages of the architecture are achieved.
`
`While two-tier systems still have their place for simple applications, three-tier client/server solutions are
`nowadays recognized as being the ideal choice for the enterprise since they are more maintainable and
`supportable, and are flexible to evolve to ever-changing business requirements.
`
`10
`
`Apple Inc. Exhibit 1020
`
`

`
`Multi-tier Computing
`A further extension to three-tier solutions is the multi-tier or, as it is sometimes called, n-tier. These
`solutions are the most flexible and scaleable and build on all the advantages of the three-tier architecture.
`
`INTRODUCTION
`
`Personal
`Computers
`
`VOICe
`Response
`Unit
`
`. - -
`. presentat ion logic
`
`Applicat ion Server
`
`e business logic
`
`In a multi-tier clienUserver solution, the business logic is partitioned and distributed over several machines.
`As requirements change during a systems lifetime, this partitioning and deployment can be reviewed and
`amended with minimal impact. Furthermore, additional tiers are included to support multiple databases and
`other services such as message switches, legacy systems, data warehouses, communication channels and so
`on. By enabling the distribution of the workload over many CPUs (using either symmetric multiprocessing
`or massively parallel clustered technology), it is obvious how scalability-with the aim of 'no limits'-can be
`achieved. Sometimes the distribution of the logic over separate geographical regions can be considered to
`achieve optimum performance; for example, processes can be located at sites where they can limit the
`amount of slow network communications performed.
`
`Drawbacks of Multi-Tier Client/Server- Where Next?
`Unfortunately, three-tier and multi-tier clienUserver solutions are not trivial to implement. There are more
`tasks to undertake and complex issues to address than when building two-tier systems. A strong
`understanding of the multi-tier clienUserver development techniques and an appreciation of the potential
`pitfalls are vital. However with the innovation of the Internet, interest is being diverted away from clienU
`~erver architectures. Demand for dynamic content on the web has transformed web computing into a new
`~plementation of multi-tier computing, which offers solutions to many of the traditional problems of
`chenUserver. With HTML it's possible to develop an application in one language to be used on any
`?perating system. However HTML is not without its own drawbacks, such as the static nature of the pages
`It creates. This is where liS 4.0 and Active Server Pages come in ...
`
`11
`
`Apple Inc. Exhibit 1020
`
`

`
`Active Server Pages
`Fundamentals
`
`Chapter 1 we met Active Server Pages, which is Microsoft's compelling server-based technology for
`1
`:Ui!ding dynamic and interactive Web pages and we saw how useful it is for programming IIS4 Web
`solutions. We learned that ASP solutions will probably make the older methods, such as CGI, obsolete
`because ASP is much easier to implement, and, because it is built upon ISAPI technology, it overcomes
`the traditional performance problems.
`
`In this chapter, we will delve deeper in to what Active Server Pages is (or are, if you prefer to think of the
`rather odd name with which Microsoft has christened it as being plural}. We shall look at why people often
`refer to Active Server Pages as software 'glue' technology. We'll see how it manages to stick together all of
`the useful bits (supplied as software components of course} that are rapidly falling out of Microsoft and
`others to form a single integrated solution.
`
`So in this chapter we will aim to give the user an appreciation of:
`
`The capabilities of ASP and some different ways that we can use this technology
`
`How Microsoft have implemented a generic architecture for application scripting and how
`ASP actually works
`
`How to generate ASP automatically using some common Microsoft applications
`
`How to write your own ASP applications
`
`We shall build on these ideas and then take a look at a few examples of ASP applications-for each, we shall disect
`the code in order to discuss how it works.
`
`But, the first step is to take a look at what Active Server Pages is all about.
`
`Apple Inc. Exhibit 1020
`
`

`
`PROFESSIONAL
`
`ACTIVE SERVER PAGES
`
`What are Active Server Pages?
`With any new technology, the first questions you tend to ask are the obvious ones. You know the sort of
`thing-What is it? What can it do? Will it do what I want it to? Whose turn is it to make the coffee? Is
`Active Server Pages (ASP) designed for the guy who runs a Web site, or the poor IT manager who is
`trying to make an intranet do something (but he is not sure what)?
`
`Put simply, an Active Server Page is a Hie with a .ASP suffix that contains a combination of HTML
`statements and script logic. When IIS4 receives an HTTP request for an ASP Hie, the final HTML
`response is