Search

Microsoft Visual Basic Scripting Edition (VBScript) is important both as a language for the development of applications for the World Wide Web and as a scripting language for the Windows operating system itself. In the context of the Web, it is one of the most important scripting languages used for server-side applications. For client-side Web applications it is secondary to JavaScript and is limited to intranets relying exclusively on the Microsoft Internet Explorer Web browser. This chapter describes the history and use of VBScript through version 5.6. Essential elements of the language are summarized and its object-oriented programming aspects are briefly described. A few of its most important advanced features are then discussed. The chapter closes with an overview of the migration of VBScript applications to the new .NET framework. The bringing together of the previously distinct languages of Visual Basic, Visual Basic for Applications, and VBScript under Visual Basic.NET may in the future obviate the need for VBScript as a separate language. Keywords: .NET; client side applications; object-oriented programming; scripting language; server side applications; VBScript; Visual Basic

In this chapter, you’ll learn the various server-side languages available for OS X and how to use and implement them in real-world situations. Numerous options are available for budding young developers to learn, each offering advantages and, of course, disadvantages; this chapter covers the pros and cons of each language in turn.

The QR decomposition in linear algebra calculation is widely applied. Despite that the algorithms for the decomposition are available, it lacks explanations how to implement them for non-square matrices. The research gives descriptions about the modifications, needed to apply for rectangular form of matrices. A software implementation of the algorithm is presented. It can be used for client or server side programming tools, performing linear algebra calculations and optimization.

At some point in your life as a web developer, you’re going to have to work with scripting languages and Server Side Includes (SSI). I know, it’s a pain in the butt, and I resisted it as long as I could. But I eventually gave in and so will you (cue dramatic music).

This chapter demonstrates the usefulness of Macromedia Flash MX as a medium for providing interactive content. The motivation for using Flash is presented first. This is followed by an overview of Flash, a brief illustration of Flash’s animation ability, and a straightforward example of data communication from a Flash movie to an external server-side script. Furthermore, basic concepts of object-oriented programming are introduced within the context of the application. The similarity of Flash’s ActionScript to other object-oriented scripting languages is mentioned, and the important non-linear aspect of program development using Flash is pointed out. It is intended that an understanding of Flash’s underlying principles make it more accessible to a larger audience of web designers and developers.

Students in this tutorial learned how to write automated customer tests for a web-based application. They used an open-source tool kit to create tests that drive a web browser. Most completed a suite of multiple tests by the conclusion of the tutorial. This hands-on tutorial used open-source software installed on student-provided laptops. Students learned to write these tests using the Ruby scripting language and the Web Testing with Ruby toolkit, available at http://rubyforge.org/projects/wtr/. A timeclock application was used as the target of the tests.

Many Web applications use a mixture of HTML and scripting language code as the front-end to business services. Analogously to traditional applications, redundant code is introduced by copy-and-paste practices. Code duplication is a pathological form of software reuse because of its effects on the maintenance of large software systems. This paper describes how a simple semi-automated approach can be used to identity cloned functions within scripting code of Web applications. The results obtained from applying our approach to three Web applications show that the approach is useful for a fast selection of script function clones, and can be applied to prevent clone spreading or to remove redundant scripting code.

The computation of program slices on Web applications may be useful during debugging, when the amount of code to be inspected can be reduced, and during understanding, since the search for a given functionality can be better focused. The system dependence graph is an appropriate data structure for slice computation, in that it explicitly represents all dependences that have to be taken into account in slice determination. In this paper the main problems related to the construction of the system dependence graph are considered. With no loss of generality, solutions are presented with reference to the server side programming language PHP and to the client side language Javascript. Most of the difficulties concern event and hyperlink handling, dynamic generation of HTML code, and direct access to HTML elements by client code. An example of Web application is analyzed, supporting the feasibility of the approach.

One important advantage of software integration constructing a project without platform and machine boundaries. In this study, we propose a scripting mechanism to integrate UNIX tools and other software under non-UNIX systems into a new system. Based on our scripting mechanism, we assumed UNIX experts as the system users. A UNIX expert would be adaptive on this study, because the scripting language extended from a UNIX shell. In order to demonstrate this study, we then propose a multi-agent distributed scripting system (MADSS). MADSS provides a fast and a convenient way for a UNIX expert to combine the heterogeneous software distributed on a network environment. A multi-agent system was employed to be an operational environment of this study. The agents in our system could perform the distributed scripts written by UNIX users through several proposed control flows, for examples parallel, circular trip, and forth_and_back.

It is possible for users to develop their own scripts and play with downloaded scripts without risking the security of the entire system. One of the ways to achieve user scripting is by making use of the web server that runs under a different user name with lesser privileges and allow users to upload CGIs into a different CGI-BIN directory. This works reasonably well but multiple users could interfere with each other. UNIX/LINUX-based apache can be configured with suEXEC support which allows user scripts. User scripting is an optional feature in Ohio State University DECthreads HTTP Server (OSU). The SYSTEM account creates a detached process that acts as a gateway between the server and the user script execution processes. When the server recognizes that a user script needs to be run, it contacts the gateway and passes the script and user name it needs to run under. The gateway program then uses persona services to assume the needed user name and then through a proxy from that user name to itself, creates another process with which it communicates using DECnet task-to-task.

Developing interactive Web programs poses unique problems. Due to the limitations of server protocols, interactive Web programs (conceptually) consists of numerous “scripts” that communicate with each other through Web forms and other external storage. For simplistic applications, one can think of such scripts as plain functions that consume a Web page (form) and produce a Web page in response. For complex applications, this view leads to subtle, and costly, mistakes. These lecture notes explain how to overcome many of these problems with a mostly functional programming style that composes scripts via (hidden) first-class continuations.

A web-based information system for management of scientific electronic journals is presented in the paper. Journal management requires exchange of information between many participants in the publishing process, including authors, reviewers, editors, and lectors. Each participant in the process plays a different role, and cooperates with other participants. The web system is implemented using open source solutions on the Linux platform. Three-tiered information system architecture has been used. Object oriented PHP (PHP hypertext preprocessor) is used as a server side scripting language to implement the business logic. Database management system is provided by PostgreSQL, although database connection abstraction is utilized. Apache web server is used together with SSL encryption mechanism to provide HTML content to end-user. The system is currently in use for editorial support of an international scientific journal and the initial results have been encouraging.

High-performance environments are primarily required in heavy-use environments and in running low-duty-cycle applications with adequate performance. The benefit of these environments is that they produce their results without a significant cost in additional memory or CPU and can help extend the useful life of their hardware. High-performance CGI options generally summarizes to the ways used by the minimum number of different processes to minimize process creation overhead, ways to minimize the number of image activations, and ways to communicate with the web server faster than the default. Several high-performance scripting options are available. Compaq Secure Web Server (CSWS) provides persistent scripting environments for Perl, PHP, and Java through the apache modules. Ohio State University DECthreads HTTP Server (OSU) supports higher-performance environments by a mechanism called as High-Performance Server Software (HPSS). Configuration is similar in all cases, therefore, the HPSS executable is set up as a presentation script for the type of script that needs to be executed. In context to wide area surveillance division (WASD), CGIplus scripts are persistent. The variables are same in CGI, but the means of communication are different.

Electronic documents, particularly those on the World Wide Web, have an inherent structure which can be utilized. However; the tools to do so have typically been oriented towards professional programmers. We present scripting language features that can be incorporated into tools that manipulate structured network documents. This set of language features allows us to build visual tools to specify transformation on such documents. Subsequently transformation scripting, is opened up to a broad class of users. This allows the tools to be easily extended by end users. World Wide Web browsers serve as a class of tools that can take advantage of this technique. We discuss our experimental browser, Grendel, which has an embedded scripting language, CrossJam, based upon transformation scripting. Grendel has a number of novel applications and a simple visual tool, Spar, to assist in scripting the browser's behavior.

Now to integrate EDA tools to enable interoperability and ease of use has been a very time-consuming and complicated job. Conventionally, each tool comes with a unique and simple set of commands for interactive use such as Sis, Vis, and Magic, but it lacks full programming capability of a scripting language. Also, it discourages further exploration to the underlying system functionality. Not only the code is hard to reuse, but also rapid prototyping of a new algorithm is impossible. A new algorithm may still take years to develop, which has to start from scratch and struggles between various formats. In this paper, we study and address how to easily integrate those application program interface (API)'s into most popular scripting languages such as Tcl or Perl. This enables a full scripting or programming language capability into a tool, and most important of all, any tool can be interoperated over a uniform platform on an API level. Rapid prototyping of a new algorithm thus becomes much easier and faster. It also promotes software reuse. Many existing extension packages for the scripting languages can be therefore integrated such as Tk for graphic user interface (GUI), and CPAN collection for various Perl applications. From a standpoint of high software quality this approach also provides a very good vehicle for comprehensive testing of each API in an EDA tool.

The World-Wide Web represents an opportunistic Internet-based platform on which many new applications are developing rapidly. To facilitate fast Web applications, a scripting approach is one possible solution for software developers. However, then are two major drawbacks for many existing scripting tools. First, most of these scripting tools are proprietary, and only available on chosen platforms. Second, most scripting tools use the Hyper-Text Markup Language (HTML) as the basis for extension. To provide extra functionality such as database connection, various extended codes or commands are mixed with HTML tags to produce expected results. However, this dirty approach will make the design and development process more complicated. We propose a systematic and flexible scripting framework for fast Web application development. The two major components, layout script and information-processing script, naturally reflect the static and dynamic properties of a Web application. In addition, the information-processing script can flexibly be split into different component scripts to suit different applications. We built a prototype of a script parser and an Integrated Development Environment (IDE) tool to quickly develop an intelligent Web-based Personal Computer Configuration Advisor. Clearly, our proposal opens up many possible directions for investigation including the uses of the IDE tool to develop other applications, and the integration with other components to handle more complicated Web applications.

Most, if not all, mobile users seek access to dynamic content. They want immediate information. With few exceptions, people can wait for access to static content until they return to their homes or offices. However, even static content—maps, travel directions, or other material—can often be more useful with dynamic updates; for example, in the case of travel directions, up-to-date information on traffic, road hazards, and so on would be more beneficial.

This chapter describes the syntax of Mtg’s own scripting language, MtgScript. MtgScript is used to describe external objects in the library MtgLib. (The existence of MtgScript is a bit unfortunate: a new implementation would rely on a format based on XML.)

The Yoix scripting language is ideal for building web applications. Implemented using Java technology, the Yoix interpreter runs wherever Java runs. The Yoix language includes many features and constructs from both the Java and C languages. Because it uses Java technology, it is cross-platform. GUI-capable and both network and thread friendly, yet requires less coding than using Java directly. The interpreter can use URLs to access Yoix scripts via a web server. CGI interactions are equally simple. Though socket level communication methods are also available, robust and scaleable web applications can be constructed using straightforward, familiar client interactions with a web server. Such a model is being successfully used by AT&T for one of its fraud management systems. which is utilized 24/7 by hundreds of users at diverse locations. This paper briefly describes the Yoix language and focuses on its use as a tool for building web-based systems.

The design and development of hypermedia applications that are deployed on the Web and other delivery platforms is largely conducted on an intuitive, ad hoc basis, thus resulting in inefficient systems that are hard to modify, maintain and port to alternative platforms. There are now justifiable research and development efforts that attempt to formalize the engineering process of such systems in order to achieve certain quality attributes like modifiability, maintainability and portability. This paper presents such an attempt for designing a conceptual model of a hypermedia application that allows for easy update and alteration of its content as well as its presentation and also allows for deployment in various platforms. In specific this model explicitly separates the hypermedia content from its presentation to the user, by employing XML content storage and XSL transformations. Our work is based upon the empirical results of designing, developing and deploying hypermedia applications in various platforms, and on the practices of well-established hypermedia engineering techniques.

Rapid development of telecommunications networks has made possible development of telemedicine, and especially one of its segments, medical teleconsultation. We present a system which is designed to provide tools for establishing meaningful communication between general practitioner in dislocated areas and specialists typically located in large medical centers. The technological approach for implementation of the system is based on open source solutions. The system is implemented on the Linux platform. The Web server is Apache extended with support for PHP, and mod-SSL, which interfaces Apache with the Open-SSL library for data encryption. Data storage is implemented using the database management system PostgreSQL. To describe data the newly emerging XML (Extensible Markup Language) standard was used. Transformation of data is achieved using another second-generation Internet technology: XSL (Extensible Style language). CSS (Cascading Style Sheet) is technology which is used for visual rendition of transformed documents. PHP is the server side scripting language which is used to access the database and generate XML documents. It is also used to interface the Sablotron XSLT processor. PHP acts as "glue" to all pieces, and produces the Web page. The system is based on newly-emerging technologies, and it represents a basis for providing a higher level of health care.

The future of computer use is undeniably on the Web. People bank, store documents, do research, and even make and maintain friendships online. With this explosion of Web-based content and applications has come a proliferation of tools to streamline and automate people's interactions on the Web, leading many users to write Web scripts to simplify their work. With CoScripter, users can automate Web activities through scripting and share scripts with others.

The web is primarily focused on delivering content of various types using standardized transport mechanisms and data types. As a generalization of this architecture, there are also a number of technologies for defining active components, such as scripts and programs. The most widespread technology in this area is Dynamic HTML (DHTML), which uses a scripting language to add active functionality to otherwise passive HTML pages. In most cases, these actions are used to trigger some actions (ie, script portions) upon certain user actions such as mouse movements and button clicks. Scripting languages are discussed in section 8.1.

Using client-side scripting it is possible to build interactive web pages that don't need round-trips to the server for every user-event. The web browser exposes itself to the script via an object model (DOM), which means that scripts can add and remove page content, or change the position and color of elements via their style attributes. We explain the object model as implemented by Microsoft Internet Explorer by means of examples and report on our experiences of using Haskell as a programming language for client-side web scripting using the HaskellScript scripting engine.

On the UCLA Statistics WWW server there are a large number of demos and calculators that can be used in statistics teaching and research. Some of these demos require substantial amounts of computation, others mainly use graphics. These calculators and demos are implemented in various different ways, reflecting developments in WWW based computing. As usual, one of the main choices is between doing the work on the client-side (i.e. in the browser) or on the server-side (i.e. on our WWW server). Obviously, client-side computation puts fewer demands on the server. On the other hand, it requires that the client downloads Java applets, or installs plugins and/or helpers. If JavaScript is used, client-side computations will generally be slow. We also have to assume that the client is installed properly, and has the required capabilities. Requiring too much on the client-side has caused browsing machines such as Netscape Communicator to grow beyond all reasonable bounds, both in size and RAM requirements. Moreover requiring Java and JavaScript rules out such excellent browsers as Lynx or Emacs W3. For server-side computing, we can configure the server and its resources ourselves, and we need not worry about browser capabilities and configuration. Nothing needs to be downloaded, except the usual HTML pages and graphics. In the same way as on the client side, there is a scripting solution, where code is interpreted, or a ob ject-code solution using compiled code. For the server-side scripting, we use embedded languages, such as PHP/FI. The scripts in the HTML pages are interpreted by a CGI program, and the output of the CGI program is send to the clients. Of course the CGI program is compiled, but the statistics procedures will usually be interpreted, because PHP/FI does not have the appropriate functions in its scripting language. This will tend to be slow, because embedded languages do not deal efficiently with loops and similar constructs. Thus a first step towards greater efficiency is to compile the necessary primitives into the PHP/FI executable. This is easy to do, because the API is quite simple. In the extensions below, we have added the complete ranlib and dcdflib to PHP, plus some additional useful functions. The source code for these extensions, plus Solaris binaries for libranlib.a and libdcdf.a can be obtained from our server. Interpreting a PHP script, even with our new primitives, still requires starting up a CGI process for each page that is read. Again, this can be improved upon. We could use FastCGI to keep the CGI process around on a permanent basis. Instead, we have chosen a more direct method. PHP can be compiled as an Apache module, i.e. it can be compiled into the Apache HTTPD server binary. This means that PHP scripts are interpreted by the WWW server, which is always around, and which will fork additional children if necessary. No CGI processes need to be started. The PHP install process creates a libphp.a and mod_php.c in the Apache source directories, which can be used to build an enhanced server. This has the additional advantage of security, because all security features of the server can be used, and none of the pitfalls of using CGI or Java apply. Using PHP, in combination with the WWW server, also has some disadvantages. Although we can make simple static plots, using the gd library, we cannot use any dynamics, and interaction between the user and the page is somewhat limited. Java, or scripts using a client-side Xlisp-Stat as a helper, are more flexible in this respect. As a consequence, the UCLA Statistics pages still use a combined approach, with server-side PHP and CGI and client-side Xlisp-Stat and Java/JavaScript. Sometime this year, server-side Java scripting will become available, and then it seems advisable to switch as much of the code as possible to the server-side.

In computing, we often solve a complex problem by adding another level of indirection. When we want to customize large, complex systems or express fluid, rapidly changing requirements, we frequently add a scripting layer on top of the corresponding system. Scripting languages glued to applications serve an important purpose: they greatly ease the application's configuration and customization and support end-user programming by offering a safe and friendly development environment. The scripting language typically offers automatic memory management, a powerful string data type, sophisticated data structures, a rich repertoire of operations, and an intuitive API for manipulating application data and state. Additionally, by interpreting the scripting language, the application can isolate itself from undesirable effects of the scripting code, such as crashes and data corruption. With the evolution of Java and Microsoft's .Net, the niche occupied by scripting languages is rapidly shrinking.

This paper presents the scripting facilities built on top of WEBSS, an interactive system for the creation and consultation of electronic books. The sclipting environment relies on the same object-oriented software architecture used in the design of the WEBSs application, rendering it consistently integratcxi with the other components of the system. Scripts enhance the application in two ways. First, the ability to combine basic WEBSS actions allows users to easily define new high-level functions like, for example, the automatic creation of tables of contents and indexes. Secondly, the behavior of the objects that constitute an electronic book can be enriched by writing scripts that will be automatically executed each time a triggering object performs a specific action. The main originality of our scripting model resides in the fact that a script maybe attached not only to an individual object, but also to all objects of a specific class, or to all objects in a certain set.

We discuss the rapid development of a large scale data discovery service for the CMS experiment using modern AJAX techniques and the Python language. To implement a flexible interface capable of accommodating several different versions of the DBS database, we used a 'stack' approach. Asynchronous JavaScript and XML (AJAX) together with an SQL abstraction layer, template engine, code generation tool and dynamic queries provide powerful tools for constructing interactive interfaces to large amounts of data. We show how the use of these tools, with rapid development in a modern scripting language, improved the scalability and usability of the the search interface for different user communities.

The present invention is a system and method for creating and implementing transactional speech applications (SAs) using Web technologies, without reliance on server-side standard or custom services. A transactional speech application may be any application that requires interpretation of speech in conjunction with a speech recognition (SR) system, such as, for example, consumer survey systems. A speech application in accordance with the present invention is represented within a Web page, as an application script that interprets semantic objects according to a context. Any commonly known scripting language can be used to write the application script, such as JavaScript (or ECMAScript), PerlScript, and VBscript. The present invention is “Web-based” to the extent that it implements Web technologies, but it need not include or access the World Wide Web.

PHP’s popularity has generated rumors of a scripting language revolution to topple Java’s preeminence.

Scripting is an approach for constructing open applications from prepackaged software components. A scripting model characterizes and standardizes the interconnection interfaces of software components appropriate to an application domain. We present a scripting model for the domain of public administration applications, and we provide a scenario of scripting applications in this domain. This scripting model is being incorporated into a prototype visual scripting tool which provides a graphical editing facility for interactively scripting applications.

JavaScript is a powerful imperative object based language made popular by its use in web pages. It supports flexible program development by allowing dynamic addition of members to objects. Code is dynamically typed: a runtime access to a non-existing member causes an error.We suggest a static type system for JavaScript that will detect such type errors. Therefore, programmers can benefit from the flexible programming style offered by JavaScript and from the safety offered by a static type system.We demonstrate our type system with a formalism of JavaScript, JS0. Our types are structural. Members of an object type are classified into definite and potential. A potential member becomes definite upon assignment. We outline a proof that our type system is sound.

We have developed a graphical interface to allow the researcher to view and assess the quality of sequencing results using a series of program scripts developed to process data generated by automated sequencers. The scripts are written in Perl programming language and are executable under the cgibin directory of a Web server environment. The scripts direct nucleic acid sequencing trace file data output from automated sequencers to be analyzed by the phredmolecular biology program and are displayed as graphical hypertext mark-up language (HTML) pages. The scripts are mainly designed to handle 96-well microtiter dish samples, but the scripts are also able to read data from 384-well microtiter dishes 96 samples at a time. The scripts may be customized for different laboratory environments and computer configurations. Web links to the sources and discussion page are provided.