CSP is versatile. It can display inventory data that changes minute by minute. It can support Web communities with thousands of active users. It can personalize pages based on user information stored within the Caché database. It can customize pages based on the user data to different users, depending on their requirements and their security permissions. It can serve up HTML, XML, images, or other binary or textual data. And it can do all this fast, because it is tightly coupled to the high-performance Caché database.

CSP is well-suited for database applications. In addition to providing rapid access to the built-in Caché database, it provides a number of features essential for Web-based database applications including session management, page authentication, and the ability to perform interactive database operations from within a Web page.

CSP supports two styles of Web development. For those who wish to develop applications programmatically, CSP provides an object framework for creating dynamic Web pages using classes. For those who prefer to develop applications using HTML files, CSP provides an HTML-based markup language that allows the inclusion of objects and server-side scripts within Web pages. You can combine these two techniques within an application for maximum flexibility.

Caché Server Page requests are processed using a standard Web server (all the leading servers are supported) and the standard HTTP protocol. An HTTP client, typically a Web browser, requests a page from a Web server using HTTP. The Web server recognizes this as a CSP request and forwards it to Caché using a fast server API. The CSP Server running in Caché processes the request and returns a page to the Web server, which in turn sends it to the browser. CSP manages communications between the Web server and Caché and invokes application code to generate the page.

The Web Server and the Caché server are abstract components, which may be implemented by one or many computers. During development, all three components may be on a single PC. In a large scale deployment, there may be multiple Web and Caché servers in two- or three-tier configurations.

To keep this guide simple, it treats these components as though there were one of each. It also describes CSP as though it was only serving HTML pages, although almost everything applies directly to XML and other text formats and most things apply to binary formats such as images.

To be productive with CSP you should have some familiarity with the following:

Some useful resources for learning HTML and JavaScript include:

Caché comes with a set of pre-built CSP sample pages. To view these:

If you have installed Caché with the default port, this should display a list of the various sample pages along with a short description. (If you have turned on any of the advanced security features in Caché, this may display a login page.)

Caché includes a detailed online tutorial, Building Web Applications With Caché, that covers building a Web application using Caché and CSP.

No introduction to a development technology is complete without the ubiquitous “Hello, World” example. This section includes a demonstration of how to create a “Hello, World” Web page using CSP in two different ways. First, there is the programmatic version of creating a Web page objects, then there is one that shows how to create the same page using a marked-up HTML file.

You can use CSP to create dynamic Web pages by creating a subclass of the %CSP.Page class and overriding its OnPage method. Any output written to the principal device by this method is automatically sent to a Web browser and displayed as a Web page.

To create a simple, “Hello World” page programmatically, do the following:

At this point you should see “Hello, World” displayed within the browser.

This application works as follows:

These steps are at the heart of CSP: The rest of CSP's functionality is built on top of this behavior.

If you like, you can make your example application more interesting by adding more code. For example, try inserting the following lines after the line containing “Hello, World”:

 Write "<ul>",!
 For i = 1:1:10 {
    Write "<LI> This is item ", i,!
 }
 Write "</ul>",!

Now your page contains an unordered (bulleted) list of 10 items. Note that in this context Caché uses the “!” character to write a carriage return to the principal device.

Another way to use CSP is to create an HTML file and let the CSP Compiler transform it into a CSP class.

To create a “Hello,World” page using a marked-up HTML file, do the following:

As with the previous example, you should see “Hello, World” displayed within the browser.

This application works as follows:

As with the case of programmatic development, this is a purposefully oversimplified example included for pedagogical reasons. The CSP compiler is actually a specialized XML/HTML processing engine that can:

As with the programmatic example, you can make this page more interesting by adding programming logic. For example:

<html>
<body>
<b>Hello, World!</b>
<script language="CACHE" runat="server">
 // this code is executed on the server
 Write "<ul>",!
 For i = 1:1:10 {
    Write "<li> This is item ", i,!
 }
 Write "</ul>",!
</script>
</body>
</html>

As with the programmatic example, the resulting page displays an unordered (bulleted) list of 10 items.