A typical computing system includes hardware and software components. Hardware components include computing devices such as personal computers (PC), mainframe computers, and computing circuits, among others. The basic architecture of a computing device includes a central processing unit (CPU), which executes instructions, and a memory unit, which stores instructions and data. Instructions and data are transmitted from the memory unit to the CPU and the results of the CPU operations are sent back to the memory unit. Software components are application programs, which contain the set of instructions that are executed by the CPU unit. Application programs include among others, system programming software, drawing software, word processing software, spreadsheet evaluation software, enterprise resource management software, customer relationship management software, data analysis software, customer self-help software, network and storage management software, mathematical and scientific software. A computer programmer develops an application program by first coding a set of instructions in a source file using the grammar rules of a programming language. In the example of FIG. 1, a programmer writes a source file using the grammar and syntax of the Java™ programming language 82. Next, the Java™ source file passes through a Java™ compiler 84 where it gets analyzed and parsed. The parsed file is then used to generate a Java™ bytecode 86, i.e., a code that is understood by a Java Virtual Machine™ (JVM). The compiled Java™ bytecode file 86 is then stored in the memory of the computing device. When a user wants to run the particular application program the computing device retrieves the compiled Java™ bytecode file 86 from the memory, the Java Virtual Machine™ 88 executes it, and the computing results are displayed 89. The compiled Java™ bytecode file 86 may also be stored in a computer readable storage medium such as a compact disk (CD) or a magnetic floppy disk or tape. These computer readable storage media may also be used to distribute and install the application program, i.e., the compiled Java™ bytecode files, in other computing devices. This computing system is sufficient for independent computing devices.
A network-based computing system includes a central server and a plurality of computing devices, i.e., client machines, that are connected with each and to the server via a network. Application programs are stored in the central server and can be deployed to the client machines via the network. Alternatively, application programs can be installed in the client machines via a manual distribution of computer readable media such as CD or floppy disks containing the compiled application code. Network-based computing is used for large enterprises that have multiple computing devices in multiple locations that interact with each other and with the server via a network connection. An application program in the network-based computing system includes a server program that is stored in the server and a client program that is stored in the memory of a client machine. The server program runs on the server and the client program runs on one of the client machines. Large enterprises utilize network-based computing to run enterprise application such as SAP's Enterprise Resource Planning software and custom internal applications. For example, a financial services company may utilize an internal Investment Portfolio Management application to perform stock analysis. When a portfolio manager wants to do a specific stock analysis, he starts the client program for the Investment Portfolio Management application in the client machine. The client machine loads the multi-megabyte client program, and then receives and processes the portfolio manager's requests. The client machine may also send further requests to the server program via the network to gather any necessary data. Next, the client program receives the necessary data, analyzes the data and presents the result in an appropriate format to the portfolio manager.
Processes associated with network-based computing include application development, application deployment, and application execution, among others. Application development refers to the coding, compiling, and debugging of the server and client programs that can be run by the server and the various configurations and operating systems of the client machines, respectively. Application deployment refers to the distribution and installation of the various client programs in the various client machines. Application execution refers to the execution of the compiled server and client programs by the server and the various client machines of the network, respectively.
The main issues with the application development for a network-based computing system involve around client platform and device configuration incompatibilities. Client platform incompatibilities include different operating systems and different hardware. The operating systems may be various versions of Windows, Mainframe, Macintosh, Unix, Linux, and Palm™. The different hardware may be Pocket PCs, desktops, laptops, workstation, phone systems, personal digital assistants (PDA) and smart television sets. Device configuration includes the specific settings that a given application may require, such as the Dynamic Link Library (DLL) version and registry for typical Windows applications. For companies with thousands of users and client machines, client platform and device configuration incompatibilities result in a significant amount of complexity and increased costs for the development of network applications.
The main issues with the application deployment in a network-based system involve around the distribution of the client program to thousands or even hundreds of thousands of client machines and the confirmation that each client machine always contains the most appropriate version of the application. The following approaches are the most commonly used today for handling code distribution and configuration:
a) CD/Floppy disk distribution and manual installation and configuration: Information System (IS) personnel install the compiled client program from a CD or floppy disks directly onto the client computer and manually configure the application for each client computer. This manual process is repeated every time the code is upgraded. Considering that an enterprise can have thousands of desktop computers distributed in many different offices, this approach is very inefficient, time consuming and costly.
b) Manual network download, installation and configuration: This approach enables an end user to download and install the client program into his computer over a Local Area Network (LAN), a Wide Area Network (WAN) or the Internet. However, considering that the client program can be easily tens of mega bytes, downloading such a big file and configuring the application can take each user up to several hours to achieve. Considering an enterprise that has thousands of users, the amount of productivity loss due to this manual downloading process can be significant. Furthermore, in cases where the network connection is slow and has limited bandwidth (i.e., dialup or wireless connection), this is simply not a viable option.
The issue with the client program execution is that the current program execution model requires loading almost the entire program into memory before the user is able to run the application. As was mentioned above, client programs are typically multi-megabyte files and loading such big files into memory creates lengthy delays for users. Further, this execution model creates increasing demands on hardware because it requires faster CPU, bigger memory, more storage, and a faster network, all of which translate into costs and performance issues.
Alternative approaches to this static network-based computing system include the Java™ Applet approach and the Hyper Text Markup Language (HTML) web page approach. In the Java™ Applet approach the client component of a network application is written as a Java™ Applet, and the end users can access this application without the need to install it in advance. However, Java™ Applets have severe technical limitations that restrict its practical use to simple application only. For complex enterprise applications, the Java™ Applet not only performs poorly but also can easily have a footprint in excess of IMB, which requires lengthy downloading which in turn effectively prevents users from using it over the Internet or WAN. In addition, Java™ Applets require a Java Virtual Machine™ (JVM) on the client machine. The JVM™ incompatibilities and lack of JVM™ on some machines both add to the failure of wide adoption of Java™ Applets for enterprise applications.
In the HTML web page approach companies use HTML for publishing simple application screens. In this approach, the entire application is running on the server. Each screen is formatted into an HTML web page and displayed in a web browser. Some simple client-side logic can be added to the HTML page using technologies, such as JavaScript™. However, this approach is limited to applications that require minimal user interactivity and functionality. Network applications using this approach sacrifice many of the features and functionality associated with client-side computing, such as offline computing, drag&drop, multiple windows, spreadsheet behavior, among others. The “click and refresh” user interaction model associated with web browsing is not suitable for network applications because this model not only consumes significant bandwidth by sending and re-sending redundant information, but it also significantly lowers user productivity by keeping users waiting with every mouse click. In this scenario, the client-side business logic is also limited because a scripting language, such as JavaScript™, does not scale well to a large team of developers, unlike the more robust Object-oriented programming (OOP) languages like Java™ and C++. As a result, HTML is used only for simple application. Important applications are still being written as traditional Client/Server applications using OOP languages.
In summary, the current approaches for network-based computing are costly, inefficient and complicated for developers. In order to use an application, users have to go through a lengthy downloading, configuration and loading process. Whenever a new version of the application is available, users have to go through the same process again. Platform incompatibilities often prevent many users from being able to run the application at all. Companies often have to maintain a significant technical support team to manage and deal with application configuration and management. Desktops need to be constantly upgraded to keep up demands from bigger and bigger client programs. For users that are distributed over a wide area network (WAN) or even the general public Internet, where bandwidth is very limited, the current approaches are simply not viable options. Though there are alternative approaches, like HTML, which can significantly lower the client footprint and reduce the client incompatibility problem, such approaches are not able to deliver the functionality and performance required for most business applications.
Accordingly, there is a need for a network-based computing system that automates, simplifies, and optimizes the compilation, deployment, and execution of an application by any type of a client machine connected to a server via any type of a network connection.