Information & Instructions

What Is ASP? by Izzy Goodman

ASP stands for Active Server Pages and, along with other web languages like Php and Java, represents a new level of web development.

Early data programming (pre-database) : For a quick recap, the programmers of several decades ago created both the program and the data. The data was in a special file whose very structure was defined by the program. In short, the data could only be read by that specific program. Each program module that accessed the data file would begin by "formatting" the data. It would read in a record and then break it down as account number = 10 characters, customer name = 25 characters, etc. If an error in the program had the account number as 9 characters, then the program would assume that the tenth character was actually the first character of the customer name. Errors like these could result in trashing the data. If the customer came along with a request to add a new field or change the size of a field, the programmer would have to write a conversion program to operate on the existing data and then change every single program module that accessed the data. Data integrity had to be maintained by the program. If the program wasn't written properly, you could wind up with missing account numbers or two customers with the same account number.

Database programming: Somewhere down the line, someone got the bright idea to develop a database external to the program. As soon as the program opened the data file, the database itself defined the fields. The account number could only be ten characters (assuming that the database defined it as such). The program could never read part of one field and part of another by accident. If a field had to be enlarged or a new one added, it was done in the database and all the program modules automatically knew about it. At first, data integrity (missing account numbers, duplicate account numbers) were handled by the program. Eventually, databases improved so that they handled these rules (referential integrity). Once these rules were coded into the database, the programmer didn't have to worry about forgetting these rules in the program code. The database itself would issue a warning if these rules were violated.

Early Networks (pre Client-server): Early programming was done on mainframes and minis. Here the user sat at a "dumb terminal" and all the processing took place at the cpu (central processing unit) which was housed in the mainframe. The cpu was an expensive piece of equipment designed to handle many user requests. But then PCs and PC Networks proliferated. The central cpu where the data resided (the server) was not really designed to handle multiple requests simultaneously. So PC servers were mostly file servers, where their purpose was to keep the files in a central area accessible to many users. But the actual processing took place at the local user's machine. So when a user requested to see all clients who had an outstanding balance, the server sent the entire client file over to the user's machine, where the local cpu filtered the data to show only those with an outstanding balance. Transmitting all these unnecessary records over the LAN wasted a good deal of time.

Client-server: Client-server, also known as two-tiered architecture, divided the work load between the central cpu server and the client. If the user asked for all clients with a balance due, the server would do the job of filtering out the unnecessary records and send only the requested records to the client.

DLLs: Client-server nicely solved the problem of centralizing data access while not clogging the network with unnecessary data. But now the question arose, where do you put the program application? Assuming that the gigabytes of accounting, spreadsheet, statistics and other applications resided on the server, every time the user clicked an icon, megabytes of program code would have to be sent from the server to the user. We would be back to the same problem we had when megabytes of useless data were being sent. Not to mention how long the user would sit around waiting for the program to finish being sent, so that it could be executed. One way to solve this problem was through the use of files such as DLLs, dynamic link libraries. Rather than create a huge application, the program was broken into one main application with the basics and a number of small modules with specific functions that were less frequently needed. Only when the user requested one of these functions, would that DLL (or OCX, OVL, etc) be sent to his machine. But this still did not really solve the problem of multiple users all requesting the same basic code, still several megabytes in size, which would be sent from the server over and over, slowing the LAN. We could put the code on the users' machines but this would lead to at least one other problem: updating all those machines when a new version was released. With custom applications such as accounting packages, new releases can be a constant occurrence.

Three-tiered architecture: What we really needed was to do the same with program code as we did with the data. Three-tiered architecture, with languages such as ASP, is the result. Instead of just the database server, there is now a database server and an application server. The users communicate with the application server. The application server makes requests of the database server, creates the code for the page the user needs to see and sends just that page to the user. The only application that resides on the user's machine is the browser needed to communicate with the application server and view the pages being received. Browsers are fairly standard and don't get updated as frequently as a custom application. If the application is updated, the user gets the new version as soon as he hits refresh or reloads the browser. Distributing the application is also easier. There is usually no code to install on the user's machine. The application server is connected to the Internet or Intranet. The database server is connected. The user is given the URL to the application server. Anything which needs to be installed on the user's machine is "pushed" to the user by the application.

ASP: ASP can be defined as code which can be put into an html page to make it respond dynamically to user requests. It is written in a mixture of vbscript (server side) and javascript (client side). If the server is able to decode it, it can replace ASP code with HTML code and send back to the user a plain HTML page. If the user clicks view-source, he won't see the ASP code, he will see the HTML code that the ASP code produced. For an example, when you choose a specific printer or ink cartridge number from our ink page you see the list of all cartridges which matched your request. The ASP code opens a database of our products, formats an html page and displays the items. It turns the item code into a clickable link to another ASP page. When you click the link, that ASP page formats another HTML page with information about the specific item. The benefit to you: At no time did you have to download any application to connect to our database. ASP sent it all to you in a format your browser could handle. The benefit to us: We no longer have to create a new page every time we add a product to our line. We no longer have to review our pages to make sure it reflects the latest pricing. All it takes is an entry in our database and ASP does the rest.

Code Example

Save Now!

Epson Ink
HP ink cartridges
HP Ink
HP laser cartridges
HP Laser
Brother ink cartridges
Brother Ink
Brother laser cartridges
Brother Laser
Canon ink cartridges
Canon Ink
Canon laser cartridges
Samsung laser cartridges


Subscribe to our free monthly newsletter Information on free software, the latest electronic devices, virus and scam warnings, incredible rebates and get the secret bonus code! Then enter the code in the box on the epson order page for discounts on many items.




About Us    Contact Us    Our Guarantee    Payment Methods   
Customer Testimonials    Our Thoughts on Customer service    Privacy and Security