Prior art

Prior Art Analysis for U.S. Patent 7,246,351

As of April 30, 2026, the following analysis details the most relevant prior art cited during the examination of U.S. Patent 7,246,351. This analysis focuses on the potential for these references to anticipate the independent claims of the '351 patent under 35 U.S.C. § 102.

The core invention of U.S. Patent 7,246,351 is a two-stage deployment system. First, a generic "assembler" or "virtual machine" is installed on a client device. Second, this assembler dynamically fetches small, logic-defining text files (like XML) from a server to build and run a specific application in the client's temporary memory, without a separate installation for each application.

Cited References and Potential Anticipation

The following references were cited by the USPTO examiner during prosecution.

1. U.S. Patent No. 6,018,746: "Method and apparatus for providing a customized persistent computing environment"

• Full Citation: Tso et al., U.S. Patent No. 6,018,746, issued January 25, 2000.
• Filing Date: June 14, 1996.
• Description: This patent describes a system for providing a personalized computing environment on a client machine. A "persona" object, which contains user preferences, application data, and pointers to software components, is stored on a server. When a user logs in, a "surrogate" process on the client machine retrieves the persona and uses it to dynamically load the necessary software components (e.g., ActiveX controls, Java applets) to reconstruct the user's customized environment.
• Potential Anticipation: This patent appears to disclose several key elements of the '351 patent's claims. The "surrogate" process acts as an assembler or virtual machine that is resident on the client. It downloads "persona" information from a server, which contains the logic and pointers needed to build the user's application environment. This process of a client-side component fetching instructions from a server to dynamically assemble an application is central to the '351 patent.
  • Claims Potentially Anticipated: Claims 1 and 13. The '746 patent's surrogate downloading a persona to load software components is analogous to the '351 patent's assembler downloading text files to assemble an application.

2. U.S. Patent No. 6,199,195: "Self-upgrading distributed functional objects"

• Full Citation: Cheston et al., U.S. Patent No. 6,199,195, issued March 6, 2001.
• Filing Date: September 15, 1997.
• Description: This patent discloses a system where distributed objects (components of an application) can automatically upgrade themselves. A client application uses a "loader" to request an object from a server. The server provides a "smart proxy" to the client. This proxy contains the version information and location of the actual object. If the client's version is outdated, the proxy automatically downloads the newer version from the server.
• Potential Anticipation: While focused on self-upgrading, the mechanism described is highly relevant. The "loader" on the client is analogous to the '351 patent's assembler. It communicates with a server to download functional objects (program logic) as needed. This process of a client-side entity fetching and installing code from a server to execute an application maps closely to the core steps of claim 1. The server's role in storing and providing these objects aligns with claim 13.
  • Claims Potentially Anticipated: Claims 1 and 13. The patent's disclosure of a client-side loader that fetches and runs updated code components from a server strongly mirrors the "download and assemble" model of the '351 patent.

3. U.S. Patent No. 6,212,563: "Apparatus and method for dynamic installation of network service logic"

• Full Citation: Van Horne et al., U.S. Patent No. 6,212,563, issued April 3, 2001.
• Filing Date: November 22, 1996.
• Description: This invention describes a method for dynamically installing "service logic" onto a network device like a browser. When a user requests a service, the server sends the necessary service logic (e.g., a Java applet or script) to a service execution environment (a virtual machine) running on the client. This logic is then executed locally to provide the service. The goal is to avoid pre-installing all possible service logics on the client.
• Potential Anticipation: This reference is highly pertinent. The "service execution environment" is functionally equivalent to the "assembler program" in the '351 patent. The system explicitly details a server storing "service logic" (program logic) and sending it to the client's execution environment on-demand, which then runs it. This directly teaches the core method of both independent claims of the '351 patent.
  • Claims Potentially Anticipated: Claims 1 and 13. The '563 patent's description of a service execution environment that downloads and executes service logic sent from a server appears to anticipate the process of downloading text files with program logic to be assembled into an application.

4. U.S. Patent No. 6,338,081: "System for providing personalized, dynamically-generated and user-extensible network services on a computer network"

• Full Citation: Pitkow et al., U.S. Patent No. 6,338,081, issued January 8, 2002.
• Filing Date: October 23, 1998.
• Description: This patent relates to generating personalized web pages or services. A server stores content and "templates" which define the structure and logic of a service. A "service generator" on the server assembles a personalized service by combining templates with user data and content. The resulting service (e.g., an HTML page with embedded scripts) is then sent to the client's browser for execution.
• Potential Anticipation: This reference is less likely to anticipate but is still relevant. The assembly of the application logic happens on the server side, which differs from the '351 patent where the "assembler" is on the client. However, it discloses the concept of storing application logic in files ("templates") and dynamically assembling a functional application from them before execution. An argument could be made that moving the location of the assembly from the server to the client is an obvious modification. It does not, however, appear to directly read on the claims which require the assembler to be installed on the client device and for that assembler to perform the downloading and assembling steps.
  • Claims Potentially Anticipated: None directly under § 102. The location of the assembly (server-side vs. client-side) is a critical distinction from the claimed invention. However, it would be highly relevant for an obviousness argument under 35 U.S.C. § 103.

5. U.S. Patent No. 6,557,043: "Method for transmitting data between a server computer and a client computer"

• Full Citation: La-related et al., U.S. Patent No. 6,557,043, issued April 29, 2003.
• Filing Date: October 8, 1999.
• Description: This patent describes a system for running client-server applications where a portion of the application logic is executed on the client in an interpreter (like a Java Virtual Machine). A small "client program" is installed on the client machine. This program receives "object definitions" and data from the server, which it uses to dynamically create the user interface and execute application logic locally. This reduces server round-trips for simple UI interactions.
• Potential Anticipation: This reference is very strong prior art. The "client program" is the "assembler." It is installed on the client and receives "object definitions" (analogous to XML text files with program logic) from the server. It then uses these definitions to construct and run the application locally. This maps almost directly to the process outlined in claims 1 and 13 of the '351 patent.
  • Claims Potentially Anticipated: Claims 1 and 13. The disclosure of a resident client program that interprets object definitions received from a server to dynamically create a user interface and execute logic appears to teach all the key steps of the independent claims.

Summary of Analysis

Several patents cited by the examiner during the prosecution of U.S. Patent 7,246,351 appear to disclose systems that are conceptually very similar to the claimed invention. Specifically, U.S. Patents 6,212,563 and 6,557,043 describe architectures where a client-side execution environment or program downloads logic definitions from a server to dynamically run an application. These references seem to teach the core novelty of the '351 patent's independent claims. U.S. Patents 6,018,746 and 6,199,195 also disclose highly relevant mechanisms of client-side components fetching program logic or objects from a server for local execution. While the specific terminology varies (e.g., "assembler," "surrogate," "loader," "service execution environment"), the fundamental process of on-demand, client-side application assembly based on server-side logic files appears to be well-established in the prior art.