US 20090007160 A1
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. The system includes a client runtime environment, a server runtime environment and an object-oriented markup-business logic binding mechanism. The client runtime environment manages client side code and screen definitions. The server runtime environment dynamical compiles code to ensure client platform compatibility. The system delivers network applications on demand, by separating them into lightweight modules and delivering these modules.
1. A computer application program stored in a computer comprising:
at least one markup document;
at least one business logic component associated with and applied directly to said at least one markup document; and
an object oriented binding mechanism binding said at least one markup document to said at least business logic component.
2. The computer application program of
3. The computer application program of
4. The computer application program of
5. The computer application program of
6. The computer application program of
7. The computer application program of
8. The computer application program of
9. The computer application program of
10. The computer application program of
11. A method for developing a computer application program comprising:
providing at least one markup document;
providing at least one business logic component associated with and applied directly to said at least one markup document;
providing an object oriented binding mechanism binding said at least one markup document to said at least business logic component; and
storing said computer application into computer memory.
12. The method of
13. The method of
14. The method of
15. The method of
16. The method of
17. The method of
18. The method of
19. The method of
20. The method of
21. A network application program stored in a server memory comprising one or more modules wherein each module comprises at least one markup document, at least one business logic associate with and applied directly to said at least one markup document and an object oriented binding mechanism binding said at least one markup document to said at least business logic component.
22. The network application program of
23. The network application program of
24. The network application program of
25. The network application program of
26. The network application program of
27. The network application program of
28. The network application program of
This application is a continuation of U.S. application Ser. No. 10/754,782 filed on Jan. 9, 2004 and entitled “System and Method for Network-Based Computing” which is commonly assigned and the contents of which are expressly incorporated herein by reference.
The present invention relates to a system and a method for network-based computing, and more particularly, to network-based computing that provides network applications that can be automatically deployed, compiled, and executed by any type of a client machine connected to a server via any type of a network connection.
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
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 1 MB, 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 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.
In general, in one aspect, the invention features a computer application program including at least one markup document, at least one business logic component associated with and applied directly to the at least one markup document and an object oriented binding mechanism binding the at least one markup document to the at least business logic component and the reverse.
In general, in another aspect, the invention features a network application program having one or more modules wherein each module includes at least one markup document, at least one business logic associate with the at least one markup document and an object oriented binding mechanism binding the at least one markup document to the at least business logic component and the reverse.
In general, in another aspect, the invention features a method of binding a markup document with one or more business logic objects including coding the markup document using a markup language, coding the one or more business logic objects using an object oriented programming language and associating the markup document with the one or more business logic objects. Next, constructing an object oriented representation of the markup document thereby generating one or more markup objects. Next, firing one or more markup object events by the object oriented representation thereby invoking the one or more business logic objects for processing the events and finally manipulating the markup objects by the one or more business logic objects. The business logic objects may manipulate the markup objects via a markup object API or a Document Object Model (DOM) API.
The details of one or more embodiments of the invention are set forth in the accompanying drawings and description below. Other features, objects and advantages of the invention will be apparent from the following description of the preferred embodiments, the drawings and from the claims.
The client machine 220 includes a client runtime environment (CRE) 224 that runs outside the client web browser 230 and client-side application code 222 (or client-side business logic). In other embodiments the CRE runs inside the client web browser 230. The client side application code 222 includes Extensible Markup Language (XML) documents and procedural code. The client machine 220 is protected by a client side firewall 244 and the web server 219 is protected by a server side firewall 242. The CRE 224 processes markup documents and executes the client-side application code 222. The CRE 224 includes a client cache 226, a communication module 225, a state synchronization and persistency module 228 and other functional modules 227 such as an XML parser, a user interface, storage, security, and an execution engine. The XML Parser is responsible for parsing XML documents that come from the application server 210. The parsing results may be stored in the client cache 226 as part of the application's client side state. The user interface module is responsible for displaying the user interface and interacting with the user according to the application's XML description. The execution engine module is capable of running client side application code 222. The client cache 226 maintains the application's client side state and is updated by the CRE automatically. The synchronization and persistency module 228 is responsible for synchronizing the client cache 226 with the application server 210, and saving and/or retrieving the client cache 226 from persistent storage.
The CRE 224 is centrally managed by the SRE 214. The CRE 224 is automatically downloaded from the application server 210 and installed in the client machine 220 the first time a user access a client application. After the initial installation, the SRE 214 automatically manages the versioning and updating of the CRE 224. Different CREs 224 are used for the different client platforms. For example, different CREs are used for a Java™ Virtual Machine, a NET CLR, or a Flash Player. The executable application code formats of these three client platforms are: Java™ bytecode, .NET CLR bytecode and Flash bytecode, respectively. The application code 222 is delivered in three different executable code formats for these three client platforms, accordingly.
Referring to the example of
The compiled bytecode files 332, 334, 336, 340 may be stored in the server cache 218, shown in
This invention utilizes object-oriented programming methodology to develop object-oriented application programs. Object-oriented application programs typically model a problem using an “object model” that defines classes of objects representing elements of the problem. A class of objects is defined in terms of the relationship of the class to other classes, the data and properties (or attributes) associated with objects in the class, and the operations (or tasks) that can be performed on objects in the class. During execution of an object-oriented application program, instances of the classes in the object model, referred to as “objects,” are produced and manipulated. Computation on these “objects” is performed by calling on “methods” defined in business logic components associated with these “objects”. For example, in an accounting management program, the various accounts are defined as the program objects. Each object, i.e., account, has attributes including account name, account number, amount deposited in the account, among others. Tasks associated with these account objects may be “get account number”, “set account name”, “set account amount”, among others. Objects interact with each other and with the business logic code via events or messages. An object may fire an event (or send a message) in order to modify its own properties, or state. Events are received and processed by the subprograms or business logic components associated with these objects. Object-oriented programming languages are well known in the art and are described in “Programming languages” Chapter 11, p 435-483, edited by Robert W. Sebesta.
In the business component to markup objects binding 530, business logic components 540 can access and modify the markup objects 510 via a markup object Application Program Interface (API), or a Document Object Model (DOM) API, 531. In one embodiment, the CRE 224 parses and stores the markup document 550 into a DOM, and exposes this DOM as a set of API that can be invoked by business logic components 540. Business logic components 540 invoke this DOM API to programmatically manipulate the markup document 550 stored in the DOM. This feedback mechanism via the markup object API 531 may be “a form validation” process or an internal calculation that will result in modifying the markup objects 510. In an example of a “form validation” process the user enters in the UI a phone number that has three digits. The business logic component recognizes that a three digit phone number is not valid, rejects the input, displays an error in the UI and requests a valid phone number.
A code example 600 of the markup-business logic binding mechanism 500 is shown in
Application programs are typically multi-megabyte files. Loading such big files into memory creates lengthy delays for users and places great demands on the hardware components because it requires faster CPU, bigger memory, more storage, and a faster network, all of which translate into costs and performance issues. The present invention solves these problems by separating the application code into small independent modules each of which can be downloaded and executed independently. Referring to
Once the appropriate modules are brought in the active memory of the client machine the user interacts directly with the application through client events. Client events include among others, entering text in a screen field, moving the mouse over text or a screen button, clicking the mouse, highlighting a button in the screen, drag & drop, a window is hidden, and new data is available.
Other embodiments are within the scope of the following claims. For example, instead of downloading one module at a time, the server may package a group of modules together, or all modules together into one deployment module and downloads this deployment module to the client machine. This is particularly useful for the purpose of offline computing where all required offline computing functionality and data can be packaged into one deployment module and downloaded to the client machine at once. After such downloading, the deployment module can run on the client machine without any connectivity until further modules or data are required.
Several embodiments of the present invention have been described. Nevertheless, it will be understood that various modifications may be made without departing from the spirit and scope of the invention. Accordingly, other embodiments are within the scope of the following claims.