INTRODUCTION

The requests of a client are confirmed by internet-server techniques that work under server-side technologies. Server-side technologies pass a script explicitly on an online server to produce active websites (IBM, 2005). In essence, server-side technologies offer communicating web pages that border with databanks or other stocks of information interacting with the active content requests for complicated client communication. Such communications comprise of shopping carts, search mechanisms, page changes, and internet entries to information-based programs. These programs range from the cost of commodities to internet ticket bookings. In the past, web development fundamentally concentrated on the user’s side or client-side and related technologies. These technologies include java, CSS, and HTML (IBM, 2005). More and more websites and programs integrate techniques to handle their complicated backend user interface design (IBM, 2005). In this paper, I am going to outline, discuss, and analyse the evolution of scripting languages while offering code examples to emphasize the changes most important for program developers today. In addition, this paper will cover changes made in server-side technology as a technique that underpins scripting languages and allows their incorporation with webserver because they improved the performance of web programs in certain ways.

EVOLUTION OF SCRIPTING LANGUAGES

Inserting data into a databank is just half the processes required for using a databank on a typical website. The user now has to be capable of removing bits of this data, format them, and place them on to the website’s pages as guests to the site make contacts with the webserver (Wilson, 2004, pp.43). The databank software is just keen on keeping and serving this information and cannot carry this task out for the client. Instead, a web designer should depend on one of the numerous scripting languages that can contact the databank program. The fly of the webserver processes scripts or small software packages that a designer inserts either within HTML pages or in distinct documents connected to web pages (Wilson, 2004, pp.43). These scripts can populate a page with data from a databank. Scripting languages are nearly as old as computers. Scripting was actually the only method of utilizing a computer in the past. During the 1950s and 1960s, program writers provided punch cards to mainframe machinists and the devices operated in a batch style (Wilson, 2004, pp.44). Today, scripting languages is characterized by several types of technologies that vary in terms of online communication. This section will discuss the evolution of scripting languages by analysing the development of Job Control Language, Scripting Command Line Translators, Perl, Tcl (Tool Command Language), Python, and Ruby as language examples.

Job Control Language

During the mid-1960s, program writers noticed that carrying out all computer operations in code like replicating files was too cumbersome. As a result, technology and consulting firm IBM (International Business Machines) presented JCL (Job Control Language) (IBM, 2005).

JCL ran on the 360 operating system. Under JCL, a user could replicate a file from a single place to another by just making use of 9 lines (JOB CONTROL LANGUAGE (JCL), 2002, pp.690).

Apparently, these lines were pressed on cards in contrast to scripting a FORTRAN user interface design that would be additionally sophisticated. Programmers also used JCL to operate software using batch styles while stipulating and diverting their limits on the basis of their result. IBM’s JCL is frequently seen as one of the original scripting languages. However, while scripting languages were functional, the time they took to reply to requests were almost not as quick as today’s computers (JOB CONTROL LANGUAGE (JCL), 2002, pp.690). This is because it frequently took a minimum of 24 hours to get a feedback. I selected JCL because it is the father of scripting languages in a world that was new to computers to a certain degree. In the 1960s, a programmer could not interpret a tape without JCL. Designers had to research the compulsory JCL and punch cards. JCL is an indication of how scripting languages that followed it developed past mainframe batch modes (JOB CONTROL LANGUAGE (JCL), 2002, pp.690).

The following is a code example of JCL for a simple page interpretation of the word “car.”

//MTLUSR0 JOB (999,POK),'CICSASM',CLASS=A,MSGCLASS=H,NOTIFY=&SYSUID

|//XPIASM  PROC DSN=,MEM=

|//*****************************************************************

|//* run ASM

|//*****************************************************************

|//STEPASM EXEC PGM=ASMA90,PARM=CAR,TODAY=0M

|//SYSUT1 DD  UNIT=SYSDA,SPACE=(CYL,(1,1))

|//SYSPRINT DD SYSOUT=*

|//SYSIN    DD DSN=&DSN(&MEM),DISP=SHR

|//SYSLIN DD DISP=SHR,DSN=MTLUSR.METAL.OBJ(&MEM)

|//SYSLIB DD DISP=SHR,DSN=SYS1.1

|//           DD DISP=SHR,DSN=SINGLE.CICS.CAR

|//           DD DISP=SHR,DSN=CEE.SCEEMAC

|// PEND

|//****************************************************************

|//* BEGINNING OF COMPILES:

|//****************************************************************

|//COMP     EXEC XPIASM,DSN='DEV.METALC.SAMPCODE',MEM='CAR' (JOB CONTROL LANGUAGE (JCL), 2002, pp.690).

Scripting Command Line Translators

Command line translators are more popular for accepting simple instructions to complete complicated operations (Research and M, 2009). A popular example of a command line translator is UNIX’s Shell. In addition, command line translators also offered a means of implementing a set of simple instructions kept within a file. Other examples of command line translators include the Data General’s CLI (Command-Line Interface), DCL (Data Control Language), and Digital Equipment Cooperation’s MCR (Monitor Console Routine) (Research and M, 2009). Data General referred to their command line translators as macros, Digital Equipment Cooperation referred to the instructions as command files, and UNIX referred to them as shell scripts (Research and M, 2009). Such early scripting languages also delivered local dimensions and streaming control instruments. A few years later, programmers began using these languages for even more complicated processes that needed compiled software. I selected scripting command line translators because their compositions resembled but were not identical to C language, UNIX’s Shell, and commanding functions such as awk and sed. Command line translators tackled the syndicate problem field in a consistent composition (Research and M, 2009).

The following is a code example of a UNIX shell script.

shell                                  sample operation

(Research and M, 2009).

Perl

Several years after the development of command line translators, program writer Larry Wall developed the scripting language Perl. Perl syndicates the simplicity of shell scripting with commanding specs copied from C and a variety of UNIX services (Langley, 2003, pp.46). Some of the Perl’s strong points collectively make difficult processes possible and further simplify simple commands. Perl’s strong points include instant and simple access to ordinary expressions, catalogs, associative collections, reading any value as a scalar, running without support, spontaneous resource control, implementing a scalar as an encryption at runtime (eval), and mixing various programming models easily (Langley, 2003, pp.46). Perl users have the ability to select from several methods of carrying out the same operation or process. Wall called this principle TIMTOWTDI, standing for “There Is More Than One Way To Do It” (Langley, 2003, pp.46). During this period, object-placement was a good strategy for dealing with complications, but languages that impose the usage of object-based codes normally forced needless complications to nearly every task. Perl included scaffold for objects in an optional manner that programmers could easily combine with non-OO notations to accomplish complicated modeling when necessary (Langley, 2003, pp.46). I selected Perl because it was the first scripting language to apply the TIMTOWTDI principle.

The following is a code example of Perl with scalar dimensions.

# several processes on scalar (series) dimensions.

$fred = "Fred now";

$barney = 54;

$sum = 6 + $barney;

print 'The dimension $fred' . " has $fred.\n"; print "Total is $ total.\n";

(Langley, 2003, pp.46)

Tcl (Tool Command Language)

During the late 1980s, John Ousterhout developed Tcl (Hayes, 1999, pp. 94). Tcl is a stimulating operational language in its respective right, but its lasting influence in scripting languages is the Tk. Tk is a system for allowing inter-platform graphical programs that users can apply from inside numerous well-known scripting languages (Hayes, 1999, pp. 94). Ousterhout first designed Tcl with a special motive, which was to fix a “command language” (Hayes, 1999, pp. 94). Over the years, Tcl rapidly developed into a seasoned, free-to-learn, an overall motive scripting language (Hayes, 1999, pp. 94). I selected Tcl because it is a particularly common instrument for developing graphical programs. Other easy scripting languages contact Tcl to pull its greater GUI-creation features.

The following is a code example of Tcl language for the word “find.”

proc find {{basedir .} {screenScript {}}} { set oldwd [pwd]

cd $basedir set cwd [pwd]

set filetitles [find -noprotest * .*] set files {}

set filt [scalar length $filterScript] foreach filetitle $filetitles {

if {!$filt || [eval $screenScript [list $filetitle]]} { lappend files [file join $cwd $filetitle]

}

if {[file isdirectory $filetitle]} {

set files [concat $files [find $filetitle $screenScript]]

}

}

cd $oldwd return $files

}

(Hayes, 1999, pp. 94)

Python

Similar to Ousterhout, program writer Guido van Rossum was working on a new scripting language during the late 1980s. Guido developed Python. Different from Perl, Python’s principle is that there must be a single clear method of processing a function (Cornelis, Rodriguez, Coop, and Bower, 2012, pp. 4). This principle inflexibility is echoed in Python’s composition. Instead of wavy scaffolds to group sentences, Python uses denting or substantial white space. Instead of a semicolon to end sentences, Python makes use of the end of line (Cornelis, Rodriguez, Coop, and Bower, 2012, pp. 6). These rules might hinder ingenious program writers from encrypting information that is simply misinterpreted and restrict the adaptability of coding methods. Python does not narrow the selection of programming models. Instead, Python readily scaffolds structured, operational, object-based, and variable-based user interface design. As a result, the designer can combine these methods while using Python. After Python became popular, users coined the term “duck typing” to refer to how Python works (Cornelis, Rodriguez, Coop, and Bower, 2012, pp. 6). For instance, a class that offers the techniques anticipated for a program, then it qualifies for that program irrespective of whether it is acquired from any base group of that program or not. For Python, an object that executes the techniques a server or tester intends to demand meets the requirements of a receiver (Cornelis, Rodriguez, Coop, and Bower, 2012, pp. 7). Apparently, this simplistic type of typing freely allows polymorphism without demanding inheritance. As a result, it eradicates the necessity of complicated inheritance chains of command (Cornelis, Rodriguez, Coop, and Bower, 2012, pp. 10). I selected Python because it freely allows polymorphism without demanding inheritance.

Eradicating the need for complicated inheritance chains of command is helpful in today’s designs of web applications.

The following is a simple code example of a Python definition of the word “airplane.”

>>> airplane Passenger:

...     def   init     (sex, name, country, age):

...         self.name  = name

...         self.country    = country

...         self.age = age

...

>>> Tom = Passenger("Thomas Bender", 28, "m")

>>> print Tom

<  main  . Passenger example at 0x81a96cc>

>>> print Tom.age 28

(Cornelis, Rodriguez, Coop, and Bower, 2012, pp. 6)

Ruby

In 1995, the public receive the scripting language Ruby from program writer Yukihiro Matsumoto (Wilson, 2004, pp. 41). Matsumoto’s design principle concentrates on building a language for human interface user designers instead of for the computer or server. The outcome largely revolves around languages such as Perl and SmallTalk with permits from other languages (Wilson, 2004, pp. 41). Ruby succeeds the POLS (Principle Of Least Surprise). This means Ruby determines an average of eight methods to carry out even the easiest tasks (Wilson, 2004, pp.

42). Where it might be closely unpredictable, Ruby largely carries out what the program writer expects. In addition, Ruby accepts Perl’s principle of TIMTOWDTI. Ruby is one of the more comprehensively object-based languages today. Ruby can handle nearly any request as an object. For example, handling literals offers remarkable articulacy (Wilson, 2004, pp. 44).

However, Ruby does not users and designers to directly use categories at all unless when necessary (Could Ruby be the jewel in the crown of scripting? 2006, p. 8). If one needs to describe a function that is not a category, it in fact spreads the worldwide object category. Ruby applies duck typing while enabling any category to be renewed and spread. Due to such great adaptability, Ruby is integrated to function multi-definitively. Program writers can make Ruby codes that translate the same way as Lips, Java, or Pascal (Could Ruby be the jewel in the crown of scripting? 2006, p. 8). Designers can also adjust Ruby for readability, productivity, minimum code, intelligence, or nearly any other importance expected (Could Ruby be the jewel in the crown of scripting? 2006, p. 8). I selected Ruby because it is easily adjustable for readability, output, minimum code, intelligence, or nearly any other emphasis.

The following is a simple code example of Ruby in scalar operations.

s = "Hello. Nice to meet you?" print s.span, " [" + s + "]\n"

# Choosing an entry in a scalar offers a numeral ascii code. print s[4], "\n"

printf("%c\n", s[4])

# The [n,l] sub-scalar offers the opening status and span. The [n..m] # form offers a variety of positions, wide-ranging.

print "[" + s[4,4] + "] [" + s[6..15] + "]\n"

print "Really" * 3, "\n"

print s.index("there"), " ", s.index("How"), " ", s.index("bogus"), "\n"

print s.reverse, "\n"

(Could Ruby be the jewel in the crown of scripting? 2006, p. 8)

HOW SERVER-SIDE TECHNOLOGIES HAVE CHANGED

First, server-side technologies underpin scripting languages and allow their incorporation with webservers (Powers, 2010). Today, server-side scripting allows programmers to add a similar code in a myriad of pages from one outer file. For instance, web designers can insert their site’s list of options in an outer file and add it in each page (Yegulalp, 2013). When the designer wants to update the site’s list of options, he or she just has to send one file to the webserver and it spontaneously updates each page. This method is like using a template but the designer does not have to send each file every time he or she wants to bring the site up to date. Server-side technology is quicker and more resourceful (Yegulalp, 2013).

Second, server-side technologies make websites active today (Powers, 2010). Designers frequently use the term dynamic to day to define websites that apply server-side scripting. This is because page contents of such sites frequently adjust in response to user participation like via a search form (Yegulalp, 2013). Such sites are referred to as dynamic or active when compared to static websites. In static websites, the web programmer fixes page contents while creating the page. The word dynamic is also used to define websites that apply special features like rollovers, dwindles, or doodads like accordion screens that open and shut to show or hide content respectively (Yegulalp, 2013). However, designers confuse these applications by using the word dynamic to describe them. JavaScript regulates these active features and doodads in the user browser and do not connect with server-side scripting at all (Yegulalp, 2013).

Third, server-side scripting functions completely on the webserver and conveys the outcomes to the user as the name implies (Powers, 2010). For instance, HTML is a widespread computer encryption that underpins the internet as a “stateless” channel. Scripting languages and databank websites would simply show inactive material without the proper technologies. Server- s-de technology is one such proper technology (Powers, 2010). Today’s easiest tasks assume by majority of internet users could not complete in the absence of server-side technologies that increase HTML performance. Examples of these tasks are emailing, showing accurate dates and times, and memorizing the number of items in an online shopping cart (Powers, 2010).

Fourth, server-side scripting can operate as free sources of technology for integrating webservers (Powers, 2010). For instance, PHP instruments or urls are free sources of server-side technology that offer an incorporated webserver. PHP that functions on Linux operating systems enjoy incorporate Apache webserver because this server-side scripting and scaffolding programs are designed to work collectively (Husted, 1999). Designers frequently use word LAMP to define a series of incorporated programs. Server-side technologies enable the usage of Coder in particular settings. Server-side technologies today are vividly modest solutions to Coder problems. Server-side technologies like PHP and HTML are idea for users who are not certain where to begin or in learning institutes where installing servers and IDEs can be highly cumbersome for tutors and engineers alike (Husted, 1999).

Lastly, server-side scripting can be an immediate hacking setting and a web advancement ground past its current normal functions (Powers, 2010). Aside from allowing designers to compose new web features or effects, server-side technology can now present the ideas of webservers and a number of the key scripting languages that underpin the internet. The interface of sites integrated by server-side technologies was not clean but simple during the early days (Husted, 1999). Today, sophisticated or “heavy” sites are clean and user-friendly because of server-side technologies. These codes are applicable alongside a site’s outcome and change it in actual time. Unit tabs in user browsers practically and theoretically isolate HTML from the modes of the server-side script, which is precisely how it ought to be (Husted, 1999).

HOW SERVER-SIDE TECHNOLOGIES HAVE IMPROVED PERFORMANCE OF WEB APPLICATIONS

Server-side technology improved the functionality of web applications. For instance, java is quickest for server-side web programs (Yegulalp, 2013). Tech firm TechEmpower is operating a continuing set of performance standards for multiple common internet application servers since March 2013. Examples of these systems are Ruby and Rails or Django (Yegulalp, 2013). Every consecutive round of experiments has profited from community responses, with the standards themselves made public as free source on GitHub (Yegulalp, 2013). Parties keen on having their respective systems standardized can divide the code, include their respective experiments, and submit findings. It is amazing how many of the popular systems like Sinatra for Ruby, a variety of ASP.Net systems, and Django for Python recorded functionality that occasionally rated commands of scale beneath the top winners (Yegulalp, 2013). The latest of these frameworks, Node.js did show impressive performance but still recorded between a third and a fourth the functionality of the quickest rivals. This is a clear indication of the immense contribution made by server-side technologies towards the performance of web programs (Yegulalp, 2013).

Since 2013, tech firm Oracle has been emphasizing the all-encompassing nature of its latest Java technology (Yegulalp, 2013). The organization’s most recent ideas for Java 8 certainly entail a plan to include solutions or capabilities of developing strong web applications.

According to Oracle Java 8 will include unifying the technology’s different versions to make is simpler to compose codes across both fixed gadgets and servers. If the ARM inside a liable server operates without disruption, it might gradually resemble the others additionally (Yegulalp, 2013). One of the biggest java-associated plans for Oracle is Project Avatar, which is essentially a JavaScript and HTML5 applications layer for java to collaborate with Grizzly. Both tech firms demonstrate the changes server-side technologies have undergone over the years to tolerate diversification and improve the functionality of web services (Yegulalp, 2013).

I believe the most significant technology for improving the performance of web applications is server-side technology or scripting. Server-side scripting like PHP operate on webservers and improve how web services work in terms of response to client requests, results, time, and file extension (Yegulalp, 2013). For instance, in PHP, bang outlines are not necessary and PHP will overlook them when existent in webservers. This is a significant development for server-side scripting because former webserver settings demanded bang outlines. Web designers must use .php as the site’s url extension (Yegulalp, 2013). This means just PHP only implemented explicitly through a web link where designers could add files with extensions such as .inc (Yegulalp, 2013). These examples depict key changes of webpages because of developments in server-side technology and integration in web applications.

CONCLUSION

Scripting languages have drastically evolved during the past five decades. A scripting language regulates the function of a typically-interactive application. This function offers the application a series of tasks to carry out all in a single batch. I have outlined, discussed, and analysed the evolution of scripting languages while offering code examples to emphasize the changes most important for program developers today. In addition, I have covered changes made in server-side technology as a technique that underpins scripting languages and allows their incorporation with webserver because they improved the performance of web programs in certain ways. Web designers today know that the rate upon which a page opens or reloads is important for its success. As a result, integrating scripting languages with other technologies is crucial. I selected server-side technology as an example of third-party technologies that significantly integrate web applications.

References

• Cornelis, H, Rodriguez, A, Coop, A, & Bower, J 2012, 'Python as a Federation Tool for GENESIS 3.0', Plos ONE, 7, 1, pp. 1-11, Academic Search Premier, EBSCOhost, viewed 8 March 2014.
• 'Could Ruby be the jewel in the crown of scripting?' 2006, Computer Weekly, p. 8, Business Source Complete, EBSCOhost, viewed 8 March 2014.
• Hayes, F 1999, 'Tool Command Language', Computerworld, 33, 37, p. 94, Business Source Complete, EBSCOhost, viewed 8 March 2014.
• Husted, R., 1999. Server-Side JavaScript(TM): Developing Integrated Web Applications. [E-book] Los Angeles: Addison-Wesley. Available through APUS Research Database website
• <http://ezproxy2.apus.edu/login?url> [Accessed 8 March 2014]. IBM, 2005. Creating server-side technologies-enabled web projects. [Online]. Available at: <http://pic.dhe.ibm.com/infocenter/radhelp/v9/index.jsp?topic= %2Fcom.ibm.etools.webtoolscore.doc%2Ftopics%2Ftcrtwebprojectserversidetech.html> [Accessed 8 March 2014].
• 'JOB CONTROL LANGUAGE (JCL)' 2002, Encyclopedia Of Software Engineering, Volume 1, 1, p. 690, Applied Science & Technology Source, EBSCOhost, viewed 8 March 2014.
• Langley, N 2003, 'Perl offers a scripting tool for all', Computer Weekly, p. 46, Business Source Complete, EBSCOhost, viewed 8 March 2014.