Chapter 36 -- dynamic web document technologies

(Latest Revision: Sun May 13 23:20 2007 )

Notes On Chapter Thirty-Six -- Dynamic Web Document Technologies (CGI, ASP, JSP, PHP, ColdFusion)

36.1 Introduction

We discuss web technology that allows a web page to change each time it is accessed.

36.2 Three Basic Types of Web Documents

Static:
- A static document resides in a file on a web server.
- The server transfers the same file in response to every client request for the URL of the document.
Dynamic:
- Using a program, the server creates a new version of the document in response to each client request for the document's URL.
- The document can be different for each client request.
Active:
- In response to the request from the client the server sends a program to the client.
- The client runs the program to display and interact with the document.
- The program can continuously update the display.

36.3 Advantages and Disadvantages of Each Document Type

Static:
- advantages: simple, reliable, efficient
- disadvantages: inflexible - it can be inconvenient and costly to change static documents.
Dynamic:
- advantages: provides current information
- disadvantages:
  - document cannot change after reaching the client;
  - creators must have knowledge of programming;
  - greater demand is placed on servers;
  - it tends to take longer for the server to execute the program and transmit the document to the client;
Active:
- advantages: can update the browser user's screen continuously
- disadvantages:
  - cost of creating, testing, and running;
  - security: documents and export information;
  - requires more sophisticated browser and more powerful computer;
  - care must be taken that the programs are portable.

36.4 Implementation of Dynamic Documents

A server that handles requests for dynamic documents must interpret the URL's that clients include with their requests.
Information must be encoded in the URL's to allow the server to determine whether the client is requesting a static document or a dynamic document.
There has to be a program on the server for each possible type of dynamic document request.
When a client requests a dynamic document, the server must execute the corresponding program, capture the output, and send it to the client.

36.5 The CGI Standard

CGI stands for Common Gateway Interface
It is a popular standard for implementing dynamic documents.

36.6 Output From A CGI Program

A CGI program outputs a header followed optionally by a 'document'.
The document generally can be of any type. It does not have to be HTML. For example, the document could be plain text, word processor format, or an image file format.
The header typically contains information about the data type of the document.
The server reads the header returned by the CGI program. Therefore the server can modify its actions based on information in the header.
For example, the header can instruct the server to return a static document from a specified location.

Try: http://pollux.csustan.edu/cgi-bin/jspage

That URL takes the browser to a copy of my homepage that is stored in pollux:///user/student/jsclass/public_html/js.html. The CGI program directly referenced by the URL looks like this:
```
#!/bin/sh

#
# CS 3000 Demo
# This demonstrates CGI's ability to redirect from one URL to another
#

echo Location: /~jsclass/js.html
echo
```

36.7 An Example CGI Program

When executed, the shell script above first outputs a header using the unix echo command.
Next it executes the unix date command and relays its output.
For example, if executed at 00:25:48 Pacific Daylight Time on May 9, 2007, the script would output:
```
Content-type: text/plain

This document was created on Wed May 9 00:25:48 PDT 2007
```
Example: After reading these directions, click on the URL below. Then click on the refresh button several times while watching the screen. Finally click on the back button to return here.

The sample CGI program: http://pollux.csustan.edu/cgi-bin/date
Notice that the display changed when you hit the refresh key. That is because the client send the URL to the server again each time, and the server runs the program to generate a new document. The documents change as the time of day changes.

36.8 Parameters and Environment Variables

The CGI standard allows a client to send parameter values to the server, which can then pass them along to the CGI program. The program typically uses parameters to tailor the output to the needs of the client.
A '?' is used to separate the parameter values from the part of the URL that denotes which CGI program to use.
The server also passes along other information to the CGI program as indicated by the chart below.
Try running the "printenv" CGI below. It outputs the information it has received from the server. You can see all the information mentioned in the chart above and more.

http://pollux.csustan.edu/cgi-bin/printenv?SHOW+ME+SPORTS+JACKETS

36.9 State Information and Cookies

A server can give a browser a cookie: a small amount of information describing the outcome of previous interactions the browser had with the server site. The browser normally sends the cookie back to the server each time it makes a new request. This allows the dynamic documents to be more "conversational" with the user of the browser.
Cookies are small and can't represent much information. However a server may store any amount of information about a client in a database and use a cookie sent by a client as a key to look up information in the database.

36.10 A CGI Script With Long-Term State Information

The script below illustrates that a CGI program can store long-term state information in a file.
The example is trivial but indicates that it is possible to store all information received from a client.
Take some time to examine the script and figure out what it does.
Run the script: http://pollux.csustan.edu/cgi-bin/IP_Memory

36.11 A CGI Script With Short-Term State Information

The string after the '?' (the QUERY_STRING) is passed to the dynamic document program.
Each time the program is invoked, it can create a different document, with changes based on the content of the string.
The program can use the information in the QUERY_STRING to create URL's to put into anchors within the web page it generates.

Consider the example script below which counts the number of times it is 'visited.'


#!/bin/sh

# CS 3000 Demo 
# CGI script that maintains short-term state,
# counting the number of accesses to it. 

# Output the document header followed by a blank line 
echo Content-type: text/html
echo

# Make a shell variable out of the 'arguments' 
# portion of the client's URL 
N=$QUERY_STRING

# emit the first few characters of the web page  
echo "<HTML>"

case "x$N" in

# in case of 'empty argument' set the variable N to 1, and 
# make the web page say this is the initial page 
x)     N=1
       echo "This is the initial page.<BR><BR>"
       ;;

# case of N = a number - add one to the number, and 
# arrange for the user to see the new number in the web page. 
x[0-9]*)  N=`expr $N + 1`;
          echo "You have displayed this page $N times.<BR><BR>"
          ;;

# Otherwise declare an error.  
*)        echo "The URL you used is invalid.</HTML>"
          exit 0
          ;;
esac

# Create an anchor that links back to this same script,
# except with a new QUERY_STRING equal to N. 
# Put the anchor into the web page, so the user can 
# employ it to refresh the display. 
echo "<A HREF=\"http://$SERVER_NAME$SCRIPT_NAME?$N\">"
echo "Click here to refresh the page.</A></HTML>"

The example script is very simple. However it illustrate that there can be a continuing "conversation" between the client and the dynamic document program.
The client communicates with the program by clicking on a link that the program has placed in the document.
Clicking on the link can cause the program to execute again, using a specific QUERY_STRING as an input. There can be many links within the document, each with its own associated QUERY_STRING.
The program communicates with the client by generating a new document according to the directions indicated in the QUERY_STRING, and transmitting it to the client for display.

36.12 Forms And Interaction

The technology used in HTML forms is very similar to the idea of the CGI script in the previous section (36.11).

36.13 Server-Side Scripting Technologies

Server-side scripting technologies such as Active Server Pages (ASP), Java Server Pages (JSP), PHP: Hypertext Preprocessor (PHP) and ColdFusion speed up the generation of new dynamic pages through the use of interpreters on the server that work with document templates containing HTML and embedded scripting information.

36.14 Summary