Data processing: database and file management or data structures – Database design – Data structure types
Reexamination Certificate
2000-06-01
2003-03-18
Mizrahi, Diane D. (Department: 2175)
Data processing: database and file management or data structures
Database design
Data structure types
Reexamination Certificate
active
06535894
ABSTRACT:
BACKGROUND OF THE INVENTION
1. Field of the Invention
The present invention relates to data communication networks and to software applications suitable for use in such networks. More particularly, the present invention relates to an apparatus and method to facilitate incremental updating of program code.
2. The Background Art
As is known to those of ordinary skill in the art, the Java™ language is an object-oriented language developed by Sun Microsystems, Inc. that can be integrated into conventional Hypertext Markup Language (“HTML”) browsers, and which allows a document server to provide the browser with documents as well as with executable code. The executable code can be automatically loaded from the document server if the HTML browser determines that it does not have the appropriate code already resident on the user machine.
Typically, the executable code takes the form of application programs known as “applets” comprising “bytecodes” that are machine independent. These applets are then interpreted by operating system specific applet interpreters (virtual machines). For example, a current Internet/Web browser implementation using the Java™ language is the HotJava™ browser, also developed by Sun Microsystems, Inc.
The platform-independent nature of Java™ class files allow developers to write a single version of their applet or application, and then to deploy the applet or application on a wide variety of different hardware and operating systems. Moreover, the Java™ platform implements a very advanced security model. According to this security model, a user can run untrusted Java™ applets and applications and be certain that the integrity of his or her system and personal data is never compromised. For example, as is well known, a Java™ applet or application may be run in a “sandbox” that prevents it from causing any harm or from gaining access to private information stored on a user's system or local network.
As mentioned above, a common way of deploying Java™ applications across a network is by using Java™ applets. Applets are typically downloaded and executed by a Java™-enabled web-browser, and make it possible to deploy Java™ software over the web with no installation needed by the user.
A Java™ program (either an applet or an application) is composed of a number of classes and interfaces. Unlike many programming languages, in which a program is compiled into machine-dependent, executable program code, Java™ classes are compiled into machine independent bytecode class files. Each class contains code and data in a platform-independent format called the class file format. The computer system acting as the execution vehicle contains a program called a virtual machine, which is responsible for executing the code in Java™ classes. The virtual machine provides a level of abstraction between the machine independence of the bytecode classes and the machine-dependent instruction set of the underlying computer hardware. A “class loader” within the virtual machine is responsible for loading the bytecode class files as needed, and either an interpreter executes the bytecodes directly, or a “just-in-time” (“JIT”) compiler transforms the bytecodes into machine code, so that they can be executed by the processor.
FIG. 1
is a block diagram illustrating a sample Java™ network environment comprising a client platform
102
coupled over a network
101
to a server
100
for the purpose of accessing Java™ class files for execution of a Java™ application or applet.
In
FIG. 1
, server
100
comprises Java™ development environment
104
for use in creating the Java™ class files for a given application. The Java™ development environment
104
provides a mechanism, such as an editor and an applet viewer, for generating class files and previewing applets. A set of Java™ core classes
103
comprise a library of Java™ classes that can be referenced by source files containing other Java™ classes. From Java™ development environment
104
, one or more Java™ source files
105
are generated. Java™ source files
105
contain the programmer-readable class definitions, including data structures, method implementations and references to other classes. Java™ source files
105
are provided to Java™ compiler
106
, which compiles Java™ source files
105
into compiled “class” files
107
that contain bytecodes executable by a Java™ virtual machine. Bytecode class files
107
are stored (e.g., in temporary or permanent storage) on server
100
, and are available for download over network
101
.
Client platform
102
contains a Java™ virtual machine (“JVM”)
111
which, through the use of available native operating system (O/S) calls
112
, is able to execute bytecode class files and execute native O/S calls when necessary during execution.
Java™ class files are often identified in applet tags within an HTML (hypertext markup language) document. A web server application
108
is executed on server
100
to respond to HTTP (hypertext transport protocol) requests originating from a web client (also called a “web browser”)
113
on client
102
containing URLs (universal resource locators) to HTML documents, commonly referred to as “web pages.” When a browser application
113
executing on client platform
102
requests an HTML document, such as by forwarding URL
109
to web server
108
, the browser automatically initiates the download of the class files
107
identified in the applet tag of the HTML document. Class files
107
can be downloaded from the server and loaded into virtual machine
111
individually as needed.
A Java™ archive (“JAR”) format (also known as a “jar” format) has been developed to group class files together into a single transportable package known as a JAR file. As is known to those of ordinary skill in the art, JAR files encapsulate Java™ classes using an archived, compressed format. A JAR file can be identified in an HTML document within an applet tag. When a browser application reads the HTML document and encounters the applet tag, the JAR file is downloaded to the client computer and decompressed. Thus, a group of class files (typically, several dozens of them) may be downloaded from a server to a client in a single download transaction. After downloading and decompressing, the archived class files are available on the client system for individual loading as needed in accordance with standard class loading procedures. The archived class files remain subject to storage inefficiencies due to duplicated data between files, as well as to memory fragmentation due to the performance of separate memory allocations for each class file.
The smallest distribution unit for a Java™-based application is a class file. A class file is a self-contained unit that describes all information about a single class or interface. As mentioned above, a Java™-based application may consist of hundreds of class files and a set of other resources, such as images, resource bundles, property files, and the like. And, as mentioned above, a JAR file is a standard and convenient method of packaging a Java™-based application. Conceptually, a JAR file is a compressed archive that contains a set of class files and other resource files. Also, a JAR file contains a special directory, META-INF, which can be used to store meta-information about an application. For instance, as will be described in more detail later, the META-INF/manifest.mf entry is a text file that can contain an attribute that describes the main class of an application.
Packaging an application up into one or more JAR files has several benefits, especially when downloading code via a data communication network such as the Internet. First, downloading a JAR file using a single HTTP request is vastly more efficient than downloading each individual entry in the JAR file by itself. Second, class look-up is much more efficient if all application resources are JAR files, since unnecessary network access can be prevented. Third, an application developer can ensure predictable performance. For example, if each class file is downloaded on demand, a bro
Muller Hans E.
Schmidt Rene W.
Violet Scott R.
Mizrahi Diane D.
Sun Microsystems Inc.
Thelen Reid & Priest LLP
LandOfFree
Apparatus and method for incremental updating of archive files does not yet have a rating. At this time, there are no reviews or comments for this patent.
If you have personal experience with Apparatus and method for incremental updating of archive files, we encourage you to share that experience with our LandOfFree.com community. Your opinion is very important and Apparatus and method for incremental updating of archive files will most certainly appreciate the feedback.
Profile ID: LFUS-PAI-O-3051564