UNITED STATES PATENT AND TRADEMARK OFFICE BEFORE THE BOARD OF PATENT APPEALS AND INTERFERENCES Ex parte ERIC CASPOLE, JOSEPH COHA, ASHISH KARKARE, YANHUA LI, and VENKATESH RADHAKRISHNAN Appeal 2008-002717 1 Technology Center 2100 Decided: March 8, 2010 Before JEAN R. HOMERE, JAY P. LUCAS, and JOHN A. JEFFERY, Administrative Patent Judges. HOMERE, Administrative Patent Judge. DECISION ON APPEAL 1 Filed on April 30, 2002. The real party in interest is Hewlett-Packard Development Co., L.P. (App. Br. 2.)
I. STATEMENT OF THE CASE Appellants appeal under 35 U.S.C. 134(a) (2002) from the Examiner s final rejection of claims 1 through 31, 34, and 35. (App. Br. 2.) 2 Claims 32 and 33 are objected to as being dependent upon a rejected base claim, but would be allowable if rewritten in independent form including all of the limitations of the base claim and any intervening claims. (Fin. Rej. 13.) 3 We have jurisdiction under 35 U.S.C. 6(b) (2008). We affirm. Appellants Invention Appellants invented a method and system for debugging software applications and, in particular, for debugging a software application and a non-application-code component invoked by the executing software application. (Spec. 1, para. [0001].) According to Appellants, the claimed invention is advantageous because it integrates application-code metrics and non-application code metrics in order to present a single, consistent debug view of a runtime environment. (Spec. 4, para. [0009].) Illustrative Claim Independent claim 1 further illustrates the invention as follows: 1. A debugging system for a software application, comprising: a software application written in a platform-independent programming language; a non-application-code component invoked by said software application; and 2 All references to the Appeal Brief are to the Appeal Brief filed on May 16, 2007, which replaced the prior Appeal Brief filed on May 24, 2006. 3 See the Final Rejection entered September 20, 2005. 2
a debugging tool having a single interface with said software application and said non-application-code component for generating a debugging metric, said debugging metric including an application metric or a non-application-code metric, said debugging tool generating said application metric from said software application and said debugging tool generating said non-application-code metric from said non-application-code component. Prior Art Relied Upon The Examiner relies on the following prior art as evidence of unpatentability: Edwards 5,901,315 May 4, 1999 Coutant 6,293,712 B1 Sep. 25, 2001 Heatlie 6,633,876 B1 Oct. 14, 2003 (filed Jun. 7, 2000) JONATHAN B. ROSENBERG, HOW DEBUGGERS WORK: ALGORITHMS, DATA STRUCTURES, AND ARCHITECTURE, 1-5, (Marjorie Spencer, ed., John Wiley & Sons, Inc. 1956) (1996) (hereinafter Rosenberg ). Rejections on Appeal The Examiner rejects the claims on appeal as follows: Claims 1 through 8, 12 through 15, 17, 19 through 27, 29 through 31, 34, and 35 stand rejected under 35 U.S.C. 102(b) as being anticipated by Edwards. Claims 9 through 11 stand rejected under 35 U.S.C. 103(a) as being unpatentable over the combination of Edwards and Coutant. Claim 16 stands rejected under 35 U.S.C. 103(a) as being unpatentable over the combination of Edwards and Rosenberg. Claims 18 and 28 stand rejected under 35 U.S.C. 103(a) as being unpatentable over the combination of Edwards and Heatlie. 3
Appellants Contentions Appellants contend that Edwards disclosure of a system debug application programming interface ( API ) and a Java debug API amounts to two separate processes and interfaces required to debug the native dynamic load libraries ( DLLs ) and Java code, respectively. (App. Br. 8-10; Reply Br. 2-4.) 4 Therefore, Appellants allege that Edwards disclosure does not teach a debugging tool having a single interface with said software application and said non-application-code components, as recited in independent claim 1. (Id.) Further, Appellants argue that Edwards disclosure of an encoding scheme that enables a debug engine to inquire about Java or native method code events does not teach a debugging tool that produces separate application metric and non-application-code metric. (App. Br. 10; Reply Br. 4.) Examiner s Findings and Conclusions The Examiner finds that Appellants argument pertaining to the claimed interface between the debugging tool and the application is not commensurate in scope with the claim language. (Ans. 15-16.) 5 Additionally, the Examiner finds that Edwards disclosure of the Java virtual machine ( JVM ) running the target application under the system debug API amounts to the debugging tool utilizing the system debug API first and foremost. (Id. at 16.) Therefore, the Examiner finds that since the JVM is launched and subsequently controlled by the system debug API, the system 4 All references to the Reply Brief are to the Reply Brief filed on August 31, 2007, which replaced the prior Reply Brief filed on November 27, 2006. 5 All references to the Examiner s Answer are to the Examiner s Answer filed on July 2, 2007, which replaced the prior Examiner s Answer filed on September 27, 2006. 4
debug API amounts to a single interface between the debugging tool and the software application and non-application-code component. (Id.) Further, the Examiner finds that since Edwards debugging tool produces debug information, or metrics, and the debugging tool operates on a software application comprising Java and non-application-code components (e.g., C or C++ DLLs), Edwards disclosure teaches generating metrics for either the software application or the non-application-code. (Id. at 17.) II. ISSUE Have Appellants shown that the Examiner erred in finding that Edwards anticipates independent claim 1? In particular, the issue turns on whether: (a) Edwards teaches a debugging tool having a single interface with said software application and said non-application-code component, as recited in independent claim 1; and (b) Edwards teaches said debugging metric including an application metric or a non-application-code metric, as recited in independent claim 1. III. FINDINGS OF FACT The following Findings of Fact ( FF ) are shown by a preponderance of the evidence. Edwards 1. Edwards generally relates to a method for debugging a Java application that includes native method DLLs (e.g., C or C++ code). (Col. 1, ll. 8-11.) In particular, Edwards Figure 2 depicts debugger (19), which is 5
preferably implemented in software and is used to debug a target application that is written in Java but that optionally comprises one or more native method dynamic load libraries or [ DLLs]. (Col. 3, ll. 54-58.) The debugger (19) includes a graphical user interface ( GUI ) which provides a user-friendly interface through which the user makes debug requests and views the status of the target application being debugged. (Id. at ll. 62-67.) Further, Edwards discloses that [t]ypically, a [DLL] is written in C or C++ programming language, and thus it will be appreciated that [Edwards ] present invention provides a mechanism for simultaneously debugging Java and C/C++ code. (Id. at ll. 58-61.) 2. Edwards Figures 1 and 2 depict a computer having an operating system that implements the debugging method utilizing a system debug API, a JVM having a Java debug API, and a debugger. (Col. 2, ll. 2-4; col. 3, ll. 53-61.) In particular, Edwards discloses that the JVM is first launched under the system debug API, thereby allowing the JVM to run the target application. (Abst.; Col. 2, ll. 5-7.) Since the JVM runs the target application itself and, further, runs under the system debug API, it enables simultaneous control of the target application via the system debug API and the Java debug API. (Abst.; Col. 2, ll. 8-11.) Additionally, Edwards discloses that the debugger comprises a debug engine [that] performs the debugging work by controlling the probe to manipulate the target application (through the JVM) and to report events to the debug engine. (Col. 2, ll. 21-24.) 3. Edwards discloses that the particular source of a given event is readily identifiable based on the debugging engine s perspective. (Col. 7, ll. 22-23.) In operation, information derived during the debug routine is 6
processed to determine whether a particular event originated in the Java portion of the code or in the C/C++ portion of the code. (Id. at ll. 36-40.) Edwards discloses encoding information about locations in the Java code, stack depth, and the like, as a 32-bit address. (Id. at ll. 40-42.) The encoded address includes bits that encode the index of the stack frame of interest. (Id. at ll. 44-48.) Coutant 4. Coutant relates to the conventions for call stack unwinding and exception handling within a computer system. (Col. 1, ll. 8-10.) For example, a debugger may need to unwind the call stack to print a stack trace, while an exception handling mechanism may need to remove a number of stack frames from the call stack, and to transfer control to an exception handling routine which is located down the stack. (Id. at ll. 54-58.) 5. Coutant s Figure 2 depicts a stack unwind data structure (20) comprising a two-level structure in the form of a unwind table (22) and an information block table (24). (Col. 4, ll. 24-26.) The unwind table (22) includes an unwind table entry (or record) (26) for each active procedure, whereby each entry (26) comprises three fields: a procedure start address (28); a procedure end address (30); and an information pointer (32). (Id. at ll. 26-31.) Rosenberg 6. Rosenberg discloses utilizing debuggers to help track down, isolate, and remove bugs from software programs. (1: 12-14.) The programmer can then repair the defect, thereby allowing the program to work according to its original intent. (2: 19-20.) In particular, Rosenberg 7
discloses employing debugging approaches when a software program crashes. (3: 29-32.) IV. PRINCIPLES OF LAW Anticipation In rejecting claims under 35 U.S.C. 102, [a] single prior art reference that discloses, either expressly or inherently, each limitation of a claim invalidates that claim by anticipation. Perricone v. Medicis Pharm. Corp., 432 F.3d 1368, 1375 (Fed. Cir. 2005) (citing Minn. Mining & Mfg. Co. v. Johnson & Johnson Orthopaedics, Inc., 976 F.2d 1559, 1565 (Fed. Cir. 1992)). Anticipation of a patent claim requires a finding that the claim at issue reads on a prior art reference. In other words, if granting patent protection on the disputed claim would allow the patentee to exclude the public from practicing the prior art, then that claim is anticipated, regardless of whether it also covers subject matter not in the prior art. Atlas Powder Co. v. IRECO, Inc., 190 F.3d 1342, 1346 (Fed Cir. 1999) (internal citations omitted). Inherency In relying upon the theory of inherency, the Examiner must provide a basis in fact and/or technical reasoning to reasonably support the determination that the allegedly inherent characteristic necessarily flows from the teachings of the applied prior art. Ex parte Levy, 17 USPQ2d 1461, 1464 (BPAI 1990) (citations omitted). [A]fter the PTO establishes a prima facie case of anticipation based on inherency, the burden shifts to appellant to prove that the subject matter shown to be in the prior art does 8
not possess the characteristic relied on. In re King, 801 F.2d 1324, 1327 (Fed. Cir. 1986) (quoting In re Swinehart, 439 F.2d 210, 212-13 (CCPA 1971)). Obviousness On appeal to the Board, an applicant can overcome a rejection [under 103] by showing insufficient evidence of prima facie obviousness or by rebutting the prima facie case with evidence of secondary indicia of nonobviousness. In re Rouffet, 149 F.3d 1350, 1355 (Fed. Cir. 1998) (citation omitted). Section 103 forbids issuance of a patent when the differences between the subject matter sought to be patented and the prior art are such that the subject matter as a whole would have been obvious at the time the invention was made to a person having ordinary skill in the art to which said subject matter pertains. KSR Int'l Co. v. Teleflex Inc., 550 U.S. 398, 406 (2007). In KSR, the Supreme Court emphasized the need for caution in granting a patent based on the combination of elements found in the prior art, and discussed circumstances in which a patent might be determined to be obvious. Id. at 415 (citing Graham v. John Deere Co., 383 U.S. 1, 12 (1966)). The Court reaffirmed principles based on its precedent that [t]he combination of familiar elements according to known methods is likely to be obvious when it does no more than yield predictable results. Id. at 416. The operative question in this functional approach is thus whether the improvement is more than the predictable use of prior art elements according to their established functions. Id. at 415, 417. 9
V. ANALYSIS 35 U.S.C. 102(b) Rejection Claims 1, 21, and 29 Independent claim 1 recites, in relevant part: 1) a debugging tool having a single interface with said software application and said nonapplication-code component and 2) said debugging metric including an application metric or a non-application-code metric. As detailed in the Findings of Fact section above, Edwards discloses a debugger that removes bugs from a target application written in Java, but which optionally comprises one or more native method DLLs. (FF 1.) In particular, Edwards discloses that a DLL is written in C or C++ programming language. (Id.) Further, Edwards discloses that the debugger includes a GUI, whereby a user makes debug requests and views the status of the debugging process. (Id.) We find that Edwards disclosure teaches a debugger that simultaneously tracks down, isolates, and removes bugs from a target application and DLLs written in C/C++ code utilizing a single GUI. In particular, we find that Edwards disclosure of a target application and DLLs written in C/C++ code amounts to a software application and nonapplication code components. Thus, we find that Edwards disclosure teaches a debugging tool having a single interface with said software application and said non-application-code component, as recited in independent claim 1. Further, Edwards discloses deriving information during the debugging process. (FF 3.) We find that Edwards disclosure of deriving debugging information amounts to generating characteristics or attributes relating to the runtime environment of a software application. In particular, we find that 10
Edwards disclosure teaches a debugger that generates characteristics or attributes pertaining to the runtime environment of a software application and corresponding non-application code. Thus, we find that Edwards disclosure teaches said debugging metric including an application metric or a non-application-code metric, as recited in independent claim 1. Alternatively, we note that the claimed phrase a debugging tool having a single interface with said software application and said nonapplication code component, may be broadly, but reasonably construed as a debugging tool having a single interface for a software application and a single interface for a non-application code component. Assuming arguendo that Edwards disclosure of a system debug API and a Java debug API amounts to two separate interfaces for debugging the native DLLs and Java code, as Appellants contend (App. Br. 8-10; Reply Br. 2-4), we find that the scope of the claim does not preclude a debugging tool having a single interface for a software application and a single interface for a nonapplication code component. It follows that Appellants have not shown that the Examiner erred in finding that Edwards anticipates independent claim 1. Appellants do not provide separate arguments for patentability with respect to independent claims 21 and 29. Therefore, we select independent claim 1 as representative of the cited claims. Consequently, Appellants have not shown error in the Examiner s rejection of independent claims 21 and 29 for the reasons set forth in our discussion of independent claim 1. See 37 C.F.R. 41.37(c)(1)(vii) (2008). Claims 2 through 4, 12 through 15, 17, 19, 22 through 27, 30, 31, 34, and 35 Appellants do not provide separate arguments for patentability with respect to dependent claims 2 through 4, 12 through 15, 17, 19, 22 through 11
27, 30, 31, 34, and 35. Therefore, we select independent claim 1 as representative of the cited claims. Consequently, Appellants have not shown error in the Examiner s rejection of dependent claims 2 through 4, 12 through 15, 17, 19, 22 through 27, 30, 31, 34, and 35 for the reasons set forth in our discussion of independent claim 1. See 37 C.F.R. 41.37(c)(1)(vii). Claims 5 and 6 Appellants contend that Edwards disclosure of Java code information, including a stack frame of interest, does not teach a frame attribute or a frame type. (App. Br. 11-12; Reply Br. 6-7.) Therefore, Appellants argue that Edwards disclosure does not teach said debugging metric includes a frame attribute wherein said frame attribute is a frame type, as recited in dependent claims 5 and 6. (Id.) We do not agree. As detailed in the Findings of Fact section above, Edwards discloses deriving information during the debugging process, which includes a stack frame of interest. (FF 3.) We find that Edwards disclosure teaches generating debugging information, or metrics, which include a stack frame of interest. In particular, we find that Edwards disclosure of a stack frame of interest amounts to a frame attribute of interest. Further, we find that a frame type necessarily flows from Edwards teaching of a frame attribute of interest. Thus, we find that Edwards cited disclosure teaches the disputed limitations. Alternatively, we find that the Examiner has properly shifted the burden to Appellants by providing a prima facie case in the Answer that reasonably supports the Examiner's finding of inherent anticipation with respect to Edwards disclosure of a frame attribute of interest. In response, Appellants merely allege that Edwards disclosure does not necessarily teach 12
that the frame attribute is a frame type. (App. Br. 11-12; Reply Br. 6-7.) Appellants mere allegation is insufficient to prove that the subject matter shown to be in the prior art does not possess the characteristic relied on by the Examiner. It follows that Appellants have not shown that the Examiner erred in finding that Edwards anticipates dependent claims 5 and 6. Claims 7 and 8 Appellants contend that Edwards disclosure of readily identifying the particular source of a given event does not teach a compiled frame calling convention [and] an interpreter frame calling convention, as recited in dependent claims 7 and 8. (App. Br. 12; Reply Br. 7.) We find Appellants argument unpersuasive. We note that Appellants fail to set forth substantive arguments, but rather generally allege that Edwards cited disclosure does not teach the limitations of dependent claims 7 and 8. Appellants are reminded that a statement that merely points out what the claim recites will not be considered as an argument for separate patentability of a claim. 37 C.F.R. 41.37(c)(1)(vii). Appellants are further reminded that a general allegation that the claim defines a patentable invention without specifically pointing out how the language of the claims patentably distinguishes them from the references does not constitute a persuasive response. 37 C.F.R. 1.111(b). Therefore, Appellants arguments are unpersuasive. It follows that Appellants have not shown that the Examiner erred in finding that Edwards anticipates dependent claims 7 and 8. Claim 20 Appellants contend that Edwards disclosure does not teach generating different types of metrics using a debugging tool and, therefore, 13
does not teach a debugging metric, including: an application metric, a virtual machine metric, [and] a native-code metric, as recited in independent claim 20. (App. Br. 10-11; Reply Br. 5-6.) We do not agree. As detailed in the Findings of Fact section, Edwards discloses utilizing a debugger to simultaneously debug a target application and DLLs written in C/C++ code. (FF 1.) In particular, Edwards discloses that the JVM runs the target application. (FF 2.) Further, Edwards discloses that the debugger contains a debug engine that performs the debugging work by manipulating the target application via the JVM. (Id.) We find that Edwards disclosure teaches a debugger that manipulates a JVM to track down, isolate, and remove bugs from a target application and DLLs written in C/C++ code. As set forth above, we find that Edwards disclosure teaches generating characteristics or attributes pertaining to the runtime environment of a software application and corresponding non-application code. See discussion supra. at 10-11. In summary, we find that Edwards disclosure teaches a debugger that manipulates a JVM in order to generate characteristics or attributes pertaining to the runtime environment of a software application and corresponding non-application code. Thus, we find that Edwards disclosure teaches the disputed limitations. It follows that Appellants have not shown that the Examiner erred in finding that Edwards anticipates independent claim 20. 35 U.S.C. 103(a) Rejections Claims 9 through 11 Appellants contend that Coutant s disclosure of an unwind table generated by a compiler, whereby the compiler is not a non-application 14
code component invoked by said software application, does not teach an unwind table produced through the claimed process. (App. Br. 13; Reply Br. 8-9.) Therefore, Appellants argue that Coutant s disclosure does not teach an unwind table generated by said non-application-code-component, as recited in dependent claims 9 and 10. (Id.) We do not agree. As detailed in the Findings of Fact section above, Coutant discloses utilizing a debugger to unwind a stack. (FF 4.) In particular, Coutant discloses a stack unwind data structure consisting of an unwind table that includes entries for each active procedure. (FF 5.) We find that Coutant s disclosure teaches an unwind table. As set forth above, we find that Edwards disclosure teaches generating characteristics or attributes pertaining to the runtime environment of a software application and corresponding non-application code. See discussion supra. at 10-11. In summary, we find that an ordinarily skilled artisan would readily appreciate generating an unwind table utilizing Edwards characteristics and attributes pertaining to non-application code. Thus, we find that the cited disclosures of Edwards and Coutant teach the disputed limitations. It follows that Appellants have not shown that the Examiner erred in concluding that the combination of Edwards and Coutant renders dependent claims 9 and 10 unpatentable. Appellants do not provide separate arguments for patentability with respect to dependent claim 11. Therefore, we select dependent claims 9 and 10 as representative of the cited claim. Consequently, Appellants have not shown error in the Examiner s rejection of dependent claim 11 for the reasons set forth in our discussion of dependent claims 9 and 10. See 37 C.F.R. 41.37(c)(1)(vii). 15
Claim 16 Appellants contend that Rosenberg s disclosure outlining how debugging is useful once a software application crashes does not teach how or why Edwards system could be modified to debug a software application, non-application code component, or both after a crash. (App. Br. 13-14; Reply Br. 9-10.) Therefore, Appellants argue that Rosenberg s disclosure does not teach wherein said software application, said non-application-code component or both have already crashed, as recited in dependent claim 16. (Id.) We do not agree. As detailed in the Findings of Fact section above, Rosenberg discloses utilizing debuggers to repair defects in a software application after the software application crashes. (FF 6.) We find that Rosenberg s disclosure teaches debugging a target application after it crashes. As set forth above, Edwards disclosure teaches a debugger that simultaneously tracks down, isolates, and removes bugs from a software application and non-application code. See discussion supra. at 10. In summary, we find that once a software application crashes, an ordinarily skilled artisan would readily appreciate utilizing Edwards debugger to simultaneously track down, isolate, and remove bugs from a software application and its corresponding nonapplication code. It follows that Appellants have not shown that the Examiner erred in concluding that the combination of Edwards and Rosenberg renders dependent claim 16 unpatentable. Claims 18 and 28 Appellants do not provide separate arguments for patentability with respect to dependent claims 18 and 28. Therefore, we select independent claim 1 as representative of the cited claims. Consequently, Appellants have 16
not shown error in the Examiner s rejection of dependent claims 18 and 28 for the reasons set forth in our discussion of independent claim 1. See 37 C.F.R. 41.37(c)(1)(vii). VI. CONCLUSIONS OF LAW 1. Appellants have not shown that the Examiner erred in rejecting claims 1 through 8, 12 through 15, 17, 19 through 27, 29 through 31, 34, and 35 as being anticipated under 35 U.S.C. 102(b). 2. Appellants have also not shown that the Examiner erred in rejecting claims 9 through 11, 16, 18, and 28 as being unpatentable under 35 U.S.C. 103(a). VII. DECISION 1. We affirm the Examiner s decision to reject claims 1 through 8, 12 through 15, 17, 19 through 27, 29 through 31, 34, and 35 as being anticipated under 35 U.S.C. 102(b). 2. We affirm the Examiner s decision to reject claims 9 through 11, 16, 18, and 28 as being unpatentable under 35 U.S.C. 103(a). No time period for taking any subsequent action in connection with this appeal may be extended under 37 C.F.R. 1.136(a). nhl AFFIRMED HEWLETT-PACKARD COMPANY Intellectual Property Administration 3404 E. Harmony Road Mail Stop 35 FORT COLLINS, CO 80528 17