Obviousness

Based on my analysis as of April 30, 2026, the independent claims of U.S. Patent No. 7,246,351 appear to be vulnerable to an obviousness challenge under 35 U.S.C. § 103. The core concepts of the invention—a client-side execution environment that downloads application logic from a server to dynamically assemble and run an application—were well-established in the prior art before the patent's priority date of February 20, 2001.

An obviousness analysis considers whether the differences between the claimed invention and the prior art would have been obvious to a Person Having Ordinary Skill in the Art (PHOSITA) at the time the invention was made. A PHOSITA in this field in early 2001 would have been a software developer or system architect with a bachelor's degree in computer science and several years of experience in developing client-server or web-based applications. This individual would be familiar with Java applets, browser plugins (ActiveX, Netscape Plugins), client-side scripting (JavaScript), and the emerging use of XML for data interchange and platform-independent configuration.

The following combinations of prior art, drawn from the references cited during prosecution, render the independent claims of the '351 patent obvious.

Obviousness Combination 1: U.S. Patent No. 6,212,563 (Van Horne) in view of the known properties of XML

1. Base Reference: Van Horne ('563)

The Van Horne patent forms a strong foundation for the '351 invention. Van Horne discloses:

• A "service execution environment" (a virtual machine) that resides on the client device, which is functionally identical to the '351 patent's "assembler program" (Claim 1, element 1; Claim 13, element 2).
• The server stores "service logic" (e.g., a Java applet or script), which is the '351 patent's "program logic" (Claim 1, element 3; Claim 13, element 1).
• This service logic is downloaded on-demand from the server to the client's execution environment to provide a service, directly teaching the core method of downloading and executing logic as needed (Claim 1, elements 3 & 4; Claim 13, elements 3 & 4).
• Van Horne's stated goal is to avoid pre-installing all service logic on the client, which is the same problem the '351 patent aims to solve.

2. Missing Element and Motivation to Modify

The primary distinction is the '351 patent's specific claim of using "text files" containing program logic, with the specification heavily emphasizing XML as the preferred format. Van Horne discloses "service logic" in the form of Java applets or scripts. While scripts are text-based, the '351 patent's inventive thrust is centered on a declarative, structured text format like XML to define the application's UI and logic.

A PHOSITA in 2001 would have found it obvious to implement Van Horne's "service logic" using XML. The motivation to do so would have been compelling for several well-understood reasons at the time:

• Platform Independence: XML was a W3C standard specifically designed to be a simple, platform-independent way to structure and transmit data. Using XML for the service logic would allow the same application definition to be rendered on different client operating systems (Windows, PalmOS, etc.) without modification, a key benefit highlighted in the '351 patent's own description (see FIG. 9 vs. FIG. 10).
• Ease of Development and Maintenance: Storing application logic and UI definitions in a human-readable XML file on the server (as described in the '351 patent at Col. 8, lines 4-13) is significantly easier to update and manage than recompiling and redeploying Java applets.
• Separation of Logic and Presentation: The use of markup languages to separate an application's structure and data from its presentation logic was a fundamental principle of web development. A PHOSITA would naturally look to XML as the obvious tool to define the components and logic for Van Horne's service execution environment to interpret.

Therefore, combining Van Horne's client-side execution environment with the well-known and conventional use of XML as a platform-neutral language for defining application logic and UI would have rendered the invention of claims 1 and 13 obvious. The "starter plugin" is a mere implementation detail for browser integration, which was a standard and necessary technique for invoking such client-side environments at the time.

Obviousness Combination 2: U.S. Patent No. 6,557,043 (La-related) as a standalone reference or in view of common knowledge

1. Base Reference: La-related ('043)

The La-related patent is arguably anticipatory, but at a minimum, it makes the '351 invention obvious. La-related discloses:

• A "client program" installed on the client machine, which is analogous to the "assembler" (Claim 1, element 1; Claim 13, element 2).
• This client program receives "object definitions" and data from the server, which directly corresponds to the "one or more text files comprising program logic" (Claim 1, element 3; Claim 13, element 1).
• The client program uses these definitions to dynamically create the user interface and execute application logic locally, which is the "assembling" step (Claim 1, element 4; Claim 13, element 4).

2. Analysis

The term "object definitions" as used in La-related is broad, but in the context of creating a user interface and executing logic, a text-based, structured format is a natural and obvious implementation. A PHOSITA tasked with implementing La-related's system in 2001 would have considered XML a prime candidate for structuring these "object definitions" for the exact same reasons outlined above: platform independence, readability, and ease of modification.

To the extent that La-related does not explicitly require the "object definitions" to be in a text file format like XML, it would have been an obvious design choice. There is no inventive step in choosing to represent application logic and UI components in XML, as this was a common and well-understood practice at the time for achieving cross-platform compatibility and simplifying server-side management.

Conclusion

The independent claims of U.S. Patent 7,246,351 describe a system that is a predictable combination of known elements. Prior art such as Van Horne ('563) and La-related ('043) already taught the fundamental architecture of a client-side program that downloads logic from a server to dynamically execute an application. The specific implementation choice of using XML as the format for this logic was an obvious, non-inventive step for a PHOSITA in 2001, who would have been motivated by the well-known benefits of XML for platform-independent data and application definition. The combination of these pre-existing concepts would have led directly to the system claimed in the '351 patent with a reasonable expectation of success.