[ad_1]
Server-side scripting generates dynamic web pages by executing small programs on a web server in response to client requests. Early techniques used shell scripts and the Common Gateway Interface (CGI) standard, while modern methods use interpreted scripting languages like PHP. Content retrieved from a database can be anything and nested scripts can access secondary data. Server-side scripting has evolved into content management systems (CMS) using tags to customize scripts. PHP is widely used in CMS implementations. Website maintenance involves updating the database, affecting every page with the script calling that data.
Server-side scripting is a term primarily used for delivering customized content via Hypertext Transfer Protocol (HTTP) to a web server by making the server execute small programs. These programs, usually written in a scripting language, are executed by the server when a client request arrives. Depending on the parameters supplied by the client at the time of the request, the script then generates a web page for the client. Web pages created this way are often called dynamic pages. This is in contrast to a client-side script which is sent from the server to the requesting client and then executed.
Early server-side scripting techniques arose to provide unique content for the requesting user, as well as save time by reducing manual editing of Hypertext Markup Language (HTML) documents. Server-side scripts were often small executable files containing a series of commands to be passed to the operating system. The web daemon, the software that runs the web server, would use these shell scripts to further run an additional program that resides on the host computer. This general technique was then defined in 1993 in the Common Gateway Interface (CGI) standard developed by the Internet Engineering Task Force (IETF). In most cases, these early CGI scripts were used to send database responses from the server to the requesting client.
With the development of interpreted scripting languages, such as Perl and PHP: Hypertext Preprocessor (PHP), server-side scripting methods have also evolved. The HTTP daemons were updated to include usage extensions that allowed these various scripting languages to be called from the web daemon itself, instead of being passed to the operating system on the host. With this addition, fragments of scripting language could be included within the HTML document. As the web server reads a document before sending it across the web, it checks and executes any scripts within the document.
Since the content retrieved by server-side scripting resides in a database, it can be pretty much anything. Content such as product descriptions, price changes, blog entries, images, and even formatting is stored in the database. It’s also possible to nest one server-side script snippet inside another, where the first script grabs certain data from the database, but also calls a second script that accesses the secondary data. This is useful, for example, when providing fairly customized standard content with additional nested content that may be time-sensitive or still unknown, such as comments on a blog entry. Website maintenance then involves updating the data in the database, which will then affect every page of the website with the script included to call that data.
Many of the server side scripting techniques have been further developed into what are known as content management systems (CMS). PHP is probably the most widely used language for this purpose, running at the heart of many CMS implementations. Here, a user who manages a website running on a CMS will modify his HTML documents to include so-called tags. Tags are essentially signals to the CMS to tell it which script to include in the document. The CMS can then be customized by creating additional scripts and associated tags.
[ad_2]