DETAILED ACTION
This is the initial office action based on the application submitted on January 05, 2024.
Claims 1-14 are pending.
Notice of Pre-AIA or AIA Status
The present application, filed on or after March 16, 2013, is being examined under the first inventor to file provisions of the AIA .
Priority
Receipt is acknowledged of certified copies of papers required by 37 CFR 1.55.
Claim Interpretation
During patent examination, the pending claims must be "given their broadest reasonable
interpretation consistent with the specification." See MPEP § 2111. Under a broadest reasonable
interpretation (BRI), words of the claim must be given their plain meaning, unless such meaning
is inconsistent with the specification. The plain meaning of a term means the ordinary and
customary meaning given to the term by those of ordinary skill in the art at the relevant time.
The ordinary and customary meaning of a term may be evidenced by a variety of sources,
including the words of the claims themselves, the specification, the drawings, and the prior art.
See MPEP § 2111.01(1).
Applicant is entitled to be their own lexicographer and may rebut the presumption that
claim terms are to be given their ordinary and customary meaning by clearly setting forth a
definition of the term that is different from its ordinary and customary meaning(s) in the
specification at the relevant time. Where an explicit definition is provided by the Applicant for a
term, that definition will control interpretation of the term as it is used in the claim. See MPEP §
2111.01 (IV)(A). Any such lexicographic definition for a term will be expressly noted by the
Examiner in the prior art rejections of the claims.
Claim Mapping
For clarity of the prosecution history record, the Examiner has provided annotations
clearly in the prior art rejections of the claims to aid the Applicant in understanding the
Examiner's interpretations of the claimed invention and the prior art, such as emphasizing
notable and relevant portions of the prior art citations, using item-to-item matching to the prior art citations, pairing exact claim language to particular language used in the prior art citations,
and/or clearly explaining the Examiner's interpretation as to how prior art citations map to the
claim language, especially when there is no one-to-one matching of terms. Furthermore, the
annotations are provided in the prior art rejections of the claims at the Examiner's discretion
where the Examiner deemed to be appropriate and necessary.
Claim Objections
Claims 3, 6, and 13 are objected to because of the following informalities:
Claim 3 recites “the object-management function to store”. It should read “wherein the object-management function is configured to store” or “the object-management function stores”
Claim 6 recites “terminates operating on the data object”. It should read “terminates operation on the data object”.
Claim 13 recites “wherein first data type defines”. It should read “wherein the first data type defines”
Double Patenting
The nonstatutory double patenting rejection is based on a judicially created doctrine
grounded in public policy (a policy reflected in the statute) so as to prevent the unjustified or
improper timewise extension of the "right to exclude" granted by a patent and to prevent possible
harassment by multiple assignees. A nonstatutory obviousness-type double patenting rejection is
appropriate where the conflicting claims are not identical, but at least one examined application
claim is not patentably distinct from the reference claim(s) because the examined application
claim is either anticipated by, or would have been obvious over, the reference claim(s). See, e.g.,
In re Berg, 140 F.3d 1428, 46 USPQ2d 1226 (Fed. Cir. 1998); In re Goodman, 11 F.3d 1046, 29
USPQ2d 2010 (Fed. Cir. 1993); In re Longi, 759 F.2d 887, 225 USPQ 645 (Fed. Cir. 1985); In
re Van Ornum, 686 F.2d 937, 214 USPQ 761 (CCPA 1982); In re Vogel, 422 F.2d 438, 164
USPQ 619 (CCPA 1970); and In re Thorington, 418 F.2d 528, 163 USPQ 644 (CCPA 1969).
A timely filed terminal disclaimer in compliance with 37 CPR 1.321 (c) or 1.321(d) may be used to overcome an actual or provisional rejection based on a nonstatutory double patenting ground provided the conflicting application or patent either is shown to be commonly owned with this application, or claims an invention made as a result of activities undertaken within the scope of a joint research agreement.
See MPEP § 2146 et seq. for applications not subject to examination under the first inventor to file provisions of the AIA . A terminal disclaimer must be signed in compliance with 37 CFR 1.321(b).
Effective January 1, 1994, a registered attorney or agent of record may sign a terminal disclaimer. A terminal disclaimer signed by the assignee must fully comply with 37 CFR 3.73(b). See MPEP § 717.02 for applications subject to examination under the first inventor to file provisions of the AIA as explained in MPEP § 2159.
Claim 14 is provisionally rejected on the ground of nonstatutory obviousness-type double patenting as being unpatentable over Claim 1 of copending Application No. 18/405,699 (hereinafter " ‘699 ") in view of US Patent No. US 6,842,786 B1. (hereinafter " Webb ").
Examiner respectfully submits the relevant portions of MPEP §§ 804(II)(B)(3) and 804(II)(B)(4) with emphasis added for purposes of convenience in discussion and illustration:
MPEP § 804(II)(B) Nonstatutory Double Patenting
A nonstatutory double patenting rejection is appropriate where the conflicting claims are not identical, but at least one examined application claim is not patentably distinct from the reference claim(s) because the examined application claim is either anticipated by, or would have been obvious over, the reference claim(s). See, e.g., In re Berg, 140 F.3d 1428, 46 USPQ2d 1226 (Fed. Cir. 1998); In re Goodman, 11 F.3d 1046, 29 USPQ2d 2010 (Fed. Cir. 1993); In re Longi, 759 F.2d 887, 225 USPQ 645 (Fed. Cir. 1985).
MPEP § 804(II)(B)(3) Obviousness Analysis
Any nonstatutory double patenting rejection made under the obviousness analysis
should make clear:
(A) The differences between the inventions defined by the conflicting claims — a
claim in the patent compared to a claim in the application; and
(B) The reasons why a person of ordinary skill in the art would conclude that the
invention defined in the claim at issue would have been an obvious variation of
the invention defined in a claim in the patent.
MPEP § 804(II)(B)(4) One-Way Test for Distinctness
If the patent term filing date of an application under examination is the same or later than that of a reference application or patent, only a one-way determination of distinctness is needed in resolving the issue of double patenting, i.e., whether the invention claimed in the application would have been anticipated by, or an obvious variation of, the invention claimed in the reference application or patent. See, e.g., In re Berg, 140 F.3d 1428, 1435, 46 USPQ2d 1226, 1231-32 (Fed. Cir. 1998). The court in Berg applied a one-way test where an applicant filed two separate applications even though all claims could have been filed in a single application, because the applicant's action could have resulted in an improper timewise extension of rights if one patent expired later than the other. If a claimed invention in the application would have been obvious over a claimed invention in the patent, there would be an unjustified timewise extension of the patent and a nonstatutory double patenting rejection is proper. According to the Berg court, improperly extending the patent term "is precisely the result that the doctrine of obviousness-type double patenting was created to prevent." Id.
Similarly, even if the application under examination has the earlier patent term filing date, only a one-way determination of distinctness is needed to support a double patenting rejection in the absence of a finding: (A) that "the PTO is solely responsible for any delays" in prosecution of that application (In re Hubbell, 709 F.3d 1140, 1150, 106 USPQ2d 1032, 1039 (Fed. Cir. 2013)); and (B) that the applicant could not have filed the conflicting claims in a single (i.e., the earlier-filed) application (In re Kaplan, 789 F.2d 1574, 229 USPQ 678 (Fed. Cir. 1986)).
It is noted that the instant application is a copending application of ‘699. It is also noted
that both ‘699 and the instant application were filed by the same inventive entity and by a
common assignee/owner. Claim 1 of '699 recite almost all the limitations of Claim 14 of the instant application, while also reciting further limitations. However, Claim 14 of the instant application, for example, recites the further limitation "emitting a second type for defining an object-management support object associated with the object-management function and the data type;”, “the object-management support object;", and “object-management support object to affect the first object at runtime.”.
As per Claim 14 of the instant application, for example, Webb discloses:
emitting a second type for defining an object-management support object associated with the object-management function and the data type (Webb, Column 2, Lines 49-52, “At runtime, a type creation function is called to create in the first process a first instance of a type object [support object] describing the data type. The type object has a set of associated functions for processing data having the data type [object-management support]. (emphasis added)”. Webb, Column 2, Lines 11-14, “The first type object [support object] can be a parameterized type object including an element identifying a location in memory and describing a format for the data type based on one or more type parameters in the identified location. (emphasis added)”);
the object-management support object (Webb, Column 2, Lines 49-52, “At runtime, a type creation function is called to create in the first process a first instance of a type object [support object] describing the data type. The type object has a set of associated functions for processing data having the data type [object-management support].”);
object-management support object to affect the first object at runtime (Webb, Column 2, Lines 49-52, “At runtime, a type creation function is called to create in the first process a first instance of a type object [support object] describing the data type. The type object has a set of associated functions for processing data having the data type [object-management support]. (emphasis added)”. Webb, Column 2, Lines 11-14, “The first type object [support object] can be a parameterized type object including an element identifying a location in memory and describing a format for the data type based on one or more type parameters in the identified location.”).
══════════════════════════════════════════════
Examiner's Remarks: Webb's runtime created type object maps to the claimed [second object]. Its associated functions are operable to process the data [first object]. Even though Webb calls it a "first type object", in the claim 7 mapping it is the "second object".
══════════════════════════════════════════════
Webb is considered to be analogous to ‘699 because it is in the same field of object-oriented software development. Therefore, it would have been obvious to someone of ordinary skill in the art before the effective filing date of ‘699 to incorporate the teachings of Webb into ‘699 to include:
emitting a second type for defining an object-management support object associated with the object-management function and the data type;
the object-management support object;
object-management support object to affect the first object at runtime.
The modification would be obvious because one of ordinary skill in the art would be motivated to incorporate a runtime-created type object [support object] (Webb, Column 2, Lines 43-65) so that object-management operations could use a type object [support object] to process and affect the object at runtime (Webb, Column 2, Lines 22-42).
Claim 1 of ‘699 as shown in the table below recites almost all the limitations of Claim 14
of the instant application. The further limitations recited in Claim 1 of ‘699 and Claim 14 of the
instant application are boldfaced for the Applicant's convenience.
Copending Application No. 18/405,699
Instant Application No. 18/406,003
1. A method of compiling source code having a first data type for defining a first object; and a second data type for defining a second object, the second data type referencing the first data type, such that the second object is linked to the first object, the method comprising:
14. A method of compiling source code having a data type for defining a first object, the method comprising:
encountering in the source code an object-management construct directed to one of the first or second data types, the object-management construct identifying an object-management function for affecting the one of the first or second objects at runtime;
encountering in the source code an object-management construct directed to the data type, the object-management construct identifying an object-management function for affecting the first object;
emitting a second type for defining an object-management support object associated with the object-management function and the data type;
compiling the object-management construct into type-specific instructions for accessing generic object-management instructions identified by the object-management construct;
compiling the object-management construct into type-specific instructions for accessing object-management instructions operable with the object-management support object;
and emitting the generic object-management instructions operable with the type-specific instructions to perform at runtime the identified object-management function.
and emitting the object-management instructions operable with the type-specific instructions and object-management support object to affect the first object at runtime.
This is a provisional nonstatutory double patenting rejection.
Claim Rejections - 35 USC § 112
The following is a quotation of 35 U.S.C. 112(b):
(b) CONCLUSION.—The specification shall conclude with one or more claims particularly pointing out and distinctly claiming the subject matter which the inventor or a joint inventor regards as the invention.
The following is a quotation of 35 U.S.C. 112 (pre-AIA ), second paragraph:
The specification shall conclude with one or more claims particularly pointing out and distinctly claiming the subject matter which the applicant regards as his invention.
Claim 14 is rejected under 35 U.S.C. 112(b) or 35 U.S.C. 112 (pre-AIA ), second paragraph, as being indefinite for failing to particularly point out and distinctly claim the subject matter which the inventor or a joint inventor (or for applications subject to pre-AIA 35 U.S.C. 112, the applicant), regards as the invention.
Claim 14 recites the limitation "a second type" in the line 6. The claim is rendered vague and indefinite because the claim does not recite earlier "a first type." In other words, how can there be "a second type" without "a first type." For the purposes of examination, “a second type” in the limitation “emitting a second type for defining an object-management support object associated with the object-management function and the data type;” is interpreted under the broadest reasonable interpretation as being “a second data type” and “a data type” in the preamble “A method of compiling source code having a data type for defining a first object, the method comprising:” is interpreted as being the corresponding “a first data type”.
Claim Rejections - 35 USC § 101
35 U.S.C. 101 reads as follows:
Whoever invents or discovers any new and useful process, machine, manufacture, or composition of matter, or any new and useful improvement thereof, may obtain a patent therefor, subject to the conditions and requirements of this title.
Claims 1-6 are rejected under 35 U.S.C. 101 because the claimed invention is directed to non-statutory subject matter. The claims do not fall within at least one of the four categories of patent eligible subject matter because Claim 1 is directed to source code. However, the claimed source code does not define any structural and functional interrelationships between the source code and any hardware elements of a computer, which permit the source code's functionality to be realized. Products do not have a physical or tangible form, such as information (often referred to as “data per se”) or a computer program per se (often referred to as “software per se”) when claimed as a product without any structural recitations. While on the contrary, a man-made tangible embodiment storing the source code would permit the source code's functionality to be realized. Therefore, the claimed source code is ineligible subject matter under § 101.
Claims 2-6 depend on Claim 1 and do not cure the deficiency of Claim 1. Therefore, Claims 2-6 are rejected for the same reason set forth in the rejection of Claim 1.
Claim Rejections - 35 USC § 103
The following is a quotation of 35 U.S.C. 103 which forms the basis for all obviousness rejections set forth in this Office action:
A patent for a claimed invention may not be obtained, notwithstanding that the claimed invention is not identically disclosed as set forth in section 102, if the differences between the claimed invention and the prior art are such that the claimed invention as a whole would have been obvious before the effective filing date of the claimed invention to a person having ordinary skill in the art to which the claimed invention pertains. Patentability shall not be negated by the manner in which the invention was made.
Claims 1, 2, 4, and 5 are rejected under 35 U.S.C. 103 as being unpatentable over Feng (US Patent Application Publication No. US 2016/0077853 A1) in view of Chen (US Patent Application Publication No. US 2022/0035820 A1) and Kvinge (US Patent No. US 9,201,637 B1).
Regarding Claim 1, Feng teaches:
Source code comprising (Feng, Claim 1, “A method of defining an object to process application programming interface (API) requests, the method comprising: defining a JavaScript (JS) file to define a set of behavioral descriptions of the object; defining a JS object notation (JSON) file to define a set of property descriptions of the object; (emphasis added)”):
a data type defining a data object, […] (Feng, Claim 1, “the association allows an object instantiator to instantiate the object from the behavioral description in the JS file and the property description in the JSON file.”);
Feng fails to teach:
[…] the data type having: a type name;
at least one data element;
However, Chen teaches:
the data type having: a type name (Chen, Paragraph [0064], “the basic information of the data object template includes a unique data object template identifier, a data object template name, a type of the data object and a data object template description information; (emphasis added)”);
at least one data element (Chen, Paragraph [0014], “the attribute tuple comprises at least one attribute metadata;”);
Feng and Chen are considered to be analogous to the claimed invention because both are in the same field of object-oriented software development. Therefore, it would have been obvious to someone of ordinary skill in the art before the effective filing date of the claimed invention to have modified Feng to incorporate the teachings of Chen to have:
the data type having: a type name;
at least one data element;
The modification would be obvious because one of ordinary skill in the art would be motivated “to manage data objects and their association relations to replace the existing static attribute management with dynamic adjustment of data object attribute information” (Chen, Paragraph [0049]).
Feng further teaches:
an extension indicator identifying an extensible object-management function (Feng, Paragraphs [0016-0017], “In some embodiments, the framework pre-defines one set of functions for each object that is instantiated from each model. For instance, in some embodiments, each JS object can perform the CRUD functions.
The framework of some embodiments allows additional functions to be written in the JS file in order to augment and override the set of functions of an object that is instantiated from the JS file. These additional functions can be written as hooks (e.g., function calls that are processed before or after a baseline function) that can be processed locally (e.g., on a client device) or remotely (e.g., on the server). (emphasis added)”);
══════════════════════════════════════════════
Examiner's Remarks: Feng teaches built-in CRUD object-management functions and hooks (additional functions) that extends the behavior before or after baseline functions. The hook declaration acts as the indicator identifying which object-management function is being extended. For example, beforeCreate/afterCreate, beforeUpdate, afterUpdate, etc.
══════════════════════════════════════════════
a construct defining an extension […] for execution by the object-management function when operating on the data object defined by the data type (Feng, Paragraph [0017], “These additional functions can be written as hooks (e.g., function calls that are processed before or after a baseline function) that can be processed locally (e.g., on a client device) or remotely (e.g., on the server).” Feng, Paragraph [0235], “a remote hook enables the developer to execute a function before or after a remote method is called by a client. The beforeRemote( ) function runs before the remote method and afterRemote( ) function runs after the remote method. (emphasis added)”).
The combination of Feng and Chen fails to teach:
[…] an extension compilable to instructions […]
However, Kvinge teaches:
an extension compilable to instructions (Kvinge, Column 15, Lines 11-20, “In at least one of the various embodiments, source code 502 may include one or more files of human readable/editable source code composed in one or more computer programming languages. Source code 502 may include instructions for performing one or more specific actions (a computer program) on a processor device, such as, processor 202, processor 302, or the like. In at least one of the various embodiments, compiler 504 may represent one or more applications used for generating machine code 506 from provided source code, such as, source code 502. (emphasis added))
Kvinge is considered to be analogous to the claimed invention because it is in the same field of object-oriented software development. Therefore, it would have been obvious to someone of ordinary skill in the art before the effective filing date of the claimed invention to have modified the combined teachings of Feng and Chen to incorporate the teachings of Kvinge to have:
an extension compilable to instructions
The modification would be obvious because one of ordinary skill in the art would be motivated “to managing generic objects across multiple runtime environments” (Kvinge, Column 1, Lines 6-9).
Regarding Claim 2, the rejection of Claim 1 is incorporated. Feng teaches:
the construct defines an additional argument for receiving by the object-management function prior to operating on the data object (Feng, Paragraph [0230], “The “accepts” and “returns” properties in the above table define either a single argument as an object or an ordered set of arguments as an array. (emphasis added)” Feng, Paragraphs [0236-0242], “In some embodiment, remote hooks are provided with a Context ctx object that contains transport-specific data (for HTTP: req and res). The ctx object also has a set of consistent APIs across transports. In some embodiments, applications that use loopback.rest( ) middleware, provide additional ctx properties such as ctx.req for expressing Request object; ctx.res for expressing Response object; ctx.req.accessToken for accessing token of the user calling the remote method (ctx.req.accessToken is undefined if the remote method is not invoked by a logged in user (or other principal)); and ctx.result (during afterRemote hooks) which will contain the data that is about to be sent to a client (a user can modify this object to transform data before it is sent). In addition to the hooks mentioned above, the user of some embodiments can define the following other hooks: afterInitialize, beforeValidate/afterValidate, beforeSave/afterSave, beforeCreate/afterCreate, beforeUpdate/afterUpdate, and beforeDestroy/afterDestroy. (emphasis added)”).
══════════════════════════════════════════════
Examiner's Remarks: Feng teaches augmenting CRUD/object-management functions with hooks associated with create, update, and destroy operations (Feng, Paragraph [0016-0017]). Feng further teaches that remote hooks receive context object (ctx) containing additional operation-specific data, and that input parameters can be mapped from the request body or the whole HTTP request object (Feng, Paragraph [0232-0233], [0236]). Thus, one of ordinary skill in the art would readily comprehend Feng teaches extending a baseline object-management operation to receive additional operation-specific information/arguments through hooks and request-mapped input parameters.
══════════════════════════════════════════════
Regarding Claim 4, the rejection of Claim 2 is incorporated. Feng teaches:
wherein the construct defines the additional argument as a parameter and a parameter type (Feng, Paragraph [0230], “Each individual argument has properties for:
TABLE-US-00091
PNG
media_image1.png
269
481
media_image1.png
Greyscale
”).
Regarding Claim 5, the rejection of Claim 2 is incorporated. The combination of Feng and Kvinge fails to teach:
wherein the object-management function stores the additional argument as metadata associated with the data object when operating on the data object.
However, Chen teaches:
wherein the object-management function stores the additional argument as metadata associated with the data object when operating on the data object (Chen, Paragraphs [0011-0015], “In an embodiment, the step (S101) is performed through a step of: constructing and storing a basic information and the attribute tuple of the data object template; wherein the basic information of the data object template comprises a unique data object template identifier, a data object template name, a type of the data object and a data object template description information; the attribute tuple comprises at least one attribute metadata; each of the at least one attribute metadata comprises a unique attribute metadata identifier, a unique attribute metadata type, a unique attribute metadata name, a unique attribute metadata value rule, a unique attribute metadata default value and a unique attribute metadata description information;”).
Chen is considered to be analogous to the claimed invention because it is in the same field of object-oriented software development. Therefore, it would have been obvious to someone of ordinary skill in the art before the effective filing date of the claimed invention to have modified Feng to incorporate the teachings of Chen to have:
wherein the object-management function stores the additional argument as metadata associated with the data object when operating on the data object.
The modification would be obvious because one of ordinary skill in the art would be motivated to store and manage object-related values as attributes [metadata]. (Chen, Paragraph [0049]). Thus, it would have been obvious to store the additions operation-specific argument when the evaluated condition [expression] indicates the value is permissible, so that the value can be used in later object management operations.
Claims 3 and 6 are rejected under 35 U.S.C. 103 as being unpatentable over Feng (US Patent Application Publication No. US 2016/0077853 A1), Chen (US Patent Application Publication No. US 2022/0035820 A1), Kvinge (US Patent No. US 9,201,637 B1) and further in view of Webb (US Patent No. US 6,842,786 B1).
Regarding Claim 3, the rejection of Claim 2 is incorporated. Feng teaches:
wherein the construct defines an expression for evaluation by the object-management function (Feng, Paragraph [0233], "As described above, to specify HTTP mapping for input parameters, a developer can also specify a custom mapping function. For example, the developer can specify:
TABLE-US-00094
PNG
media_image2.png
79
475
media_image2.png
Greyscale
PNG
media_image3.png
222
484
media_image3.png
Greyscale
”)
The combination of Feng and Kvinge fails to teach:
the object-management function to store the additional argument responsive to the expression evaluated at runtime resulting in a predetermined value.
However, Chen teaches:
the object-management function to store the additional argument […] (Chen, Paragraphs [0011-0015], “In an embodiment, the step (S101) is performed through a step of: constructing and storing a basic information and the attribute tuple of the data object template; wherein the basic information of the data object template comprises a unique data object template identifier, a data object template name, a type of the data object and a data object template description information; the attribute tuple comprises at least one attribute metadata; each of the at least one attribute metadata comprises a unique attribute metadata identifier, a unique attribute metadata type, a unique attribute metadata name, a unique attribute metadata value rule, a unique attribute metadata default value and a unique attribute metadata description information; (emphasis added)”).
Chen is considered to be analogous to the claimed invention because it is in the same field of object-oriented software development. Therefore, it would have been obvious to someone of ordinary skill in the art before the effective filing date of the claimed invention to have modified Feng to incorporate the teachings of Chen to have:
the object-management function to store the additional argument […]
The modification would be obvious because one of ordinary skill in the art would be motivated to store and manage object-related values as attributes [metadata]. (Chen, Paragraph [0049]). Thus, it would have been obvious to store the additions operation-specific argument when the evaluated condition [expression] indicates the value is permissible, so that the value can be used in later object management operations.
The combination of Feng, Chen, and Kvinge fails to teach:
[…] the additional argument responsive to the expression evaluated at runtime resulting in a predetermined value.
However, Webb teaches:
[…] the additional argument responsive to the expression evaluated at runtime resulting in a predetermined value (Webb, Column 2, Lines 29-34, “The first type object can have a set of properties including a limitation condition specifying a limitation on permissible values for data having the data type. Executing the unmarshalling function to decode the encoded data can include returning an error message if the data violates the limitation condition. (emphasis added)”).
Webb is considered to be analogous to the claimed invention because it is in the same field of object-oriented software development. Therefore, it would have been obvious to someone of ordinary skill in the art before the effective filing date of the claimed invention to have modified the teachings of Feng and Chen to incorporate the teachings of Webb to have:
[…] the additional argument responsive to the expression evaluated at runtime resulting in a predetermined value.
The modification would be obvious because one of ordinary skill in the art would be motivated to prevent invalid data from being processed, decoded, reconstructed, or otherwise used during runtime processing (Webb, Column 2, Lines 22-42).
Regarding Claim 6, the rejection of Claim 1 is incorporated. The combination of Feng, Chen, and Kvinge fails to teach:
wherein: the construct defines a constraint expression;
the object-management function evaluates the constraint expression when operating on the data object;
and the object-management function terminates operating on the data object responsive to the constraint expression evaluation resulting in a predetermined value.
However, Webb teaches:
wherein: the construct defines a constraint expression (Webb, Column 2, Lines 29-31, “The first type object can have a set of properties including a limitation condition specifying a limitation on permissible values for data having the data type.”);
the object-management function evaluates the constraint expression when operating on the data object (Webb, Column 2, Lines 31-34, “Executing the unmarshalling function to decode the encoded data can include returning an error message if the data violates the limitation condition.”);
and the object-management function terminates operating on the data object responsive to the constraint expression evaluation resulting in a predetermined value (Webb, Column 2, Lines 29-34, “The first type object can have a set of properties including a limitation condition specifying a limitation on permissible values for data having the data type. Executing the unmarshalling function to decode the encoded data can include returning an error message if the data violates the limitation condition.”).
Webb is considered to be analogous to the claimed invention because it is in the same field of object-oriented software development. Therefore, it would have been obvious to someone of ordinary skill in the art before the effective filing date of the claimed invention to have modified Feng to incorporate the teachings of Webb to have:
wherein: the construct defines a constraint expression;
the object-management function evaluates the constraint expression when operating on the data object;
and the object-management function terminates operating on the data object responsive to the constraint expression evaluation resulting in a predetermined value.
The modification would be obvious because one of ordinary skill in the art would be motivated to prevent invalid data from being processed, decoded, reconstructed, or otherwise used during runtime processing (Webb, Column 2, Lines 22-42).
Claims 7, 11, and 13 are rejected under 35 U.S.C. 103 as being unpatentable over Feng (US Patent Application Publication No. US 2016/0077853 A1) in view of Webb (US Patent No. US 6,842,786 B1).
Regarding Claim 7, Feng teaches:
A method of executing a computer program, operable with a first data type defining a first object, the method comprising (Feng, Paragraph [0012], “As mentioned above, some embodiments use novel JSON file structures that allow these embodiments to define rich JavaScript models [first data type], each of which can be instantiated at runtime to be an object [first object] that can process an API request (e.g., on the client or on the server). Also, as mentioned above, each model includes (1) a JSON file that describes the properties of the object, and (2) a JavaScript file that describes the behaviors of the object.”):
encountering a first instruction identifying an object-management function to affect the first object (Feng, Paragraph [0005], “In other embodiments, the abstractor simply provides a set of functions that allows the JS objects to exchange data with the backend data storages. For instance, in some embodiments, the abstractor provides create, retrieve, update, and delete (CRUD) functions [first instruction identifying an object-management function] to connect the JavaScript objects [first object] to the backend data storages.”);
Feng fails to teach:
instantiating a second object having one or more elements operable with the object-management function to affect the first object;
However, Webb teaches:
instantiating a second object having one or more elements operable with the object-management function to affect the first object (Webb, Column 2, Lines 49-52, “At runtime, a type creation function is called to create in the first process a first instance of a type object [second object] describing the data type. The type object has a set of associated functions for processing data having the data type. (emphasis added)”. Webb, Column 2, Lines 11-14, “The first type object [second object] can be a parameterized type object including an element identifying a location in memory and describing a format for the data type based on one or more type parameters in the identified location.”);
══════════════════════════════════════════════
Examiner's Remarks: Webb's runtime created type object maps to the claimed [second object]. Its associated functions are operable to process the data [first object]. Even though Webb calls it a "first type object", in the claim 7 mapping it is the "second object".
══════════════════════════════════════════════
Feng further teaches:
[…] the object management function for the first object […] (Feng, Paragraph [0005], “For instance, in some embodiments, the abstractor provides create, retrieve, update, and delete (CRUD) functions to connect the JavaScript objects [first object] to the backend data storages.”)
Feng fails to teach:
encountering a second instruction initiating the […] function for the first object; and
accessing the second object to affect the first object.
However, Webb teaches:
encountering a second instruction initiating the […] function for the first object; and (Webb, Claim 1, “the first process including a request to send to the second process data having a data type;”, Webb, Column 1, Line 67, Column 2, Lines 1-4, “The data is sent to the second process by executing the marshalling function on the data in the first process to generate encoded data and executing the unmarshalling function on the encoded data to decode the encoded data in the second process.”)
accessing the second object to affect the first object (Webb, Claim 1, “executing the marshalling function in the first process to generate encoded data, the marshalling function executed in the first process taking as input the data and the first type object [accessing the second object];”, Webb, Column 2, Lines 26-28, “Executing the unmarshalling function to decode the encoded data [to affect the first object] can include reconstructing the data [first object] in the second address space based on the type object [second object] description.”).
Webb is considered to be analogous to the claimed invention because it is in the same field of object-oriented software development. Therefore, it would have been obvious to someone of ordinary skill in the art before the effective filing date of the claimed invention to have modified Feng to incorporate the teachings of Webb to have:
instantiating a second object having one or more elements operable with the object-management function to affect the first object;
encountering a second instruction initiating the […] function for the first object; and
accessing the second object to affect the first object.
The modification would be obvious because one of ordinary skill in the art would be motivated to incorporate a runtime-created type object [support object] (Webb, Column 2, Lines 43-65) so that object-management operations (Feng, Paragraph [0005]) could use a type object [support object] to process and affect the object at runtime (Webb, Column 2, Lines 22-42).
Regarding Claim 11, the rejection of Claim 7 is incorporated. Feng teaches:
the object-management function is configured to receive a set of arguments and extensible to receive an additional argument defined in the first data type (Feng, Paragraph [0230], “The “accepts” and “returns” properties in the above table define either a single argument as an object or an ordered set of arguments as an array.” Feng, Paragraphs [0236-0242], “In some embodiment, remote hooks are provided with a Context ctx object that contains transport-specific data (for HTTP: req and res). The ctx object also has a set of consistent APIs across transports. In some embodiments, applications that use loopback.rest( ) middleware, provide additional ctx properties such as ctx.req for expressing Request object; ctx.res for expressing Response object; ctx.req.accessToken for accessing token of the user calling the remote method (ctx.req.accessToken is undefined if the remote method is not invoked by a logged in user (or other principal)); and ctx.result (during afterRemote hooks) which will contain the data that is about to be sent to a client (a user can modify this object to transform data before it is sent). In addition to the hooks mentioned above, the user of some embodiments can define the following other hooks: afterInitialize, beforeValidate/afterValidate, beforeSave/afterSave, beforeCreate/afterCreate, beforeUpdate/afterUpdate, and beforeDestroy/afterDestroy.” Feng, Paragraph [0210], “The developer can also add new properties to the JSON file after the developer has extended the model”);
══════════════════════════════════════════════
Examiner's Remarks: Feng teaches augmenting CRUD/object-management functions with hooks associated with create, update, and destroy operations (Feng, Paragraph [0016-0017]). Feng further teaches that remote hooks receive context object (ctx) containing additional operation-specific data, and that input parameters can be mapped from the request body or the whole HTTP request object (Feng, Paragraph [0232-0233], [0236]). Thus, one of ordinary skill in the art would readily comprehend Feng teaches extending a baseline object-management operation to receive additional operation-specific information/arguments through hooks and request-mapped input parameters.
══════════════════════════════════════════════
the first instruction includes a value for the additional argument; and (Feng, Paragraph [0232-0233], “In some embodiments, there are two ways to specify HTTP mapping for input parameters (i.e., what the method accepts): (1) provide an object with a source property, and (2) specify a custom mapping function. To provide an object with a source property to specify HTTP mapping for input parameters, a developer can provide an object with a source property that has one of the values shown in the following table: TABLE-US-00093
PNG
media_image4.png
137
397
media_image4.png
Greyscale
For example, an argument can get the whole request body as the value: {arg: ‘data’, type: ‘object’, http: {source: ‘body’}}. As described above, to specify HTTP mapping for input parameters, a developer can also specify a custom mapping function. For example, the developer can specify:
TABLE-US-00094
PNG
media_image2.png
79
475
media_image2.png
Greyscale
PNG
media_image3.png
222
484
media_image3.png
Greyscale
”)
Feng fails to teach:
the second object is instantiated with the value for the additional argument.
However, Webb teaches:
the second object is instantiated with the value for the additional argument (Webb, Column 2, Lines 49-52, “At runtime, a type creation function is called to create in the first process a first instance of a type object describing the data type. The type object has a set of associated functions for processing data having the data type. (emphasis added)”. Webb, Column 2, Lines 11-14, “The first type object can be a parameterized type object including an element identifying a location in memory and describing a format for the data type based on one or more type parameters in the identified location. (emphasis added)” Webb, Claim 1, “calling at runtime a type creation function to create a first type object describing the data type, the first type object having a set of associated functions for processing data, the set of associated functions including a marshalling function for encoding data and an unmarshalling function for decoding data; executing the marshalling function in the first process to generate encoded data, the marshalling function executed in the first process taking as input the data and the first type object; communicating the encoded data to the second process; and executing the unmarshalling function on the encoded data to decode the encoded data in the second process. (emphasis added)”, Webb, Column 8, Lines 20-25, “In this implementation, the corresponding decoding or unmarshalling function first decodes the encoded type descriptors, and uses these decoded descriptors to reassemble the encoded parameter values in remote server process 150's address space (emphasis added).”).
Webb is considered to be analogous to the claimed invention because it is in the same field of object-oriented software development. Therefore, it would have been obvious to someone of ordinary skill in the art before the effective filing date of the claimed invention to have modified Feng to incorporate the teachings of Webb to have:
the second object is instantiated with the value for the additional argument.
The modification would be obvious because one of ordinary skill in the art would be motivated to incorporate a runtime-created type object [support object] (Webb, Column 2, Lines 43-65) so that object-management operations could use a type object [support object] to process and affect the object at runtime (Webb, Column 2, Lines 22-42).
Regarding Claim 13, the rejection of Claim 7 is incorporated. Feng teaches:
wherein first data type defines a constraint expression for extending the object-management function […] (Feng, Paragraph, [0244], “A schema imposes restrictions on the model. If a remote client tries to save a product with extra properties (e.g., description), those properties are removed before the application saves the data in the model. Also, since name is a required value, the model will only be saved if the product contains a value for the name property. Rather than modifying the error responses returned by the server, the developer of some embodiments can localize the error message on the client. The validation error response contains error codes in error.details.codes, which enables clients to map errors to localized messages.”),
Feng fails to teach:
[…] and the second object is instantiated with the constraint expression,
accessing the constraint expression from the second object;
evaluating the constraint expression; and
terminating the object-management function responsive to the constraint expression evaluating to a predetermined value.
However, Webb teaches:
[…] and the second object is instantiated with the constraint expression (Webb, Column 1, Lines 61-64, “At runtime, a type creation function is called to create a first type object describing the data type. The first type object has a set of associated functions for processing data having the data type.” Webb, Column 2, Lines 29-31, “The first type object can have a set of properties including a limitation condition specifying a limitation on permissible values for data having the data type.”),
accessing the constraint expression from the second object (Webb, Claim 9, “the first type object has a set of properties including a limitation condition specifying a limitation on permissible values for data having the data type; and executing the unmarshalling function to decode the encoded data includes returning an error message if the data violates the limitation condition.”);
evaluating the constraint expression; and (Webb, Claim 9, “the first type object has a set of properties including a limitation condition specifying a limitation on permissible values for data having the data type; and executing the unmarshalling function to decode the encoded data includes returning an error message if the data violates the limitation condition.”)
terminating the object-management function responsive to the constraint expression evaluating to a predetermined value (Webb, Column 2, Lines 31-34, “Executing the unmarshalling function to decode the encoded data can include returning an error message if the data violates the limitation condition.”).
Webb is considered to be analogous to the claimed invention because it is in the same field of object-oriented software development. Therefore, it would have been obvious to someone of ordinary skill in the art before the effective filing date of the claimed invention to have modified Feng to incorporate the teachings of Webb to have:
[…] and the second object is instantiated with the constraint expression,
accessing the constraint expression from the second object;
evaluating the constraint expression; and
terminating the object-management function responsive to the constraint expression evaluating to a predetermined value.
The modification would be obvious because one of ordinary skill in the art would be motivated to prevent invalid data from being processed, decoded, reconstructed, or otherwise used during runtime processing (Webb, Column 2, Lines 22-42).
Claims 8, 9, 10, and 12 are rejected under 35 U.S.C. 103 as being unpatentable over Feng (US Patent Application Publication No. US 2016/0077853 A1) in view of Webb (US Patent No. US 6,842,786 B1), and further in view of Chen (US Patent Application Publication No. US 2022/0035820 A1).
Regarding Claim 8, the rejection of Claim 7 is incorporated. Feng fails to teach:
wherein: the object-management function is a create function
the first data type defines at least one data element; the first instruction includes an initial value for the at least one data element;
the second instruction identifies a first object name;
the method further comprising instantiating the first object with the first object name and the initial value accessed from the second object
However, Chen teaches:
wherein: the object-management function is a create function (Chen, Paragraph [0016-0018], "In an embodiment, the step (S102) is performed through a step of: based on the basic attribute metadata and the reference attribute metadata defined by the data object template, operating a data object entity and a data object directed edge to complete creation, update and deletion of the data object; the creation of the data object comprises: (emphasis added)”);
the first data type defines at least one data element; the first instruction includes an initial value for the at least one data element; (Chen, Paragraph [0018-0019] the creation of the data object comprises: creating the data object entity represented and stored by nodes of a computer graph and the data object directed edge represented and stored by directed edges of the computer graph based on the data object template constructed in step (S101), where the data object entity comprises a unique data object identifier and at least one key-value pair for storing basic attribute values, and the data object template identifier is used as a data object entity label; a key in each of the at least one key-value pair is an attribute metadata identifier of the basic attribute metadata; a value in each of the at least one key-value pair corresponds to an attribute value defined by the basic attribute metadata; (emphasis added)”)
the method further comprising instantiating the first object with the first object name and the initial value accessed from the second object ([0018-0019], “the creation of the data object comprises: creating the data object entity represented and stored by nodes of a computer graph and the data object directed edge represented and stored by directed edges of the computer graph based on the data object template constructed in step (S101), where the data object entity comprises a unique data object identifier and at least one key-value pair for storing basic attribute values, and the data object template identifier is used as a data object entity label; a key in each of the at least one key-value pair is an attribute metadata identifier of the basic attribute metadata; a value in each of the at least one key-value pair corresponds to an attribute value defined by the basic attribute metadata; the data object directed edge is configured to define a reference association between the data object entity and another data object entity through a label whose value is an attribute metadata identifier of a reference attribute metadata that defines the reference association, and when definition of the reference attribute metadata allows multiple reference associations, multiple data object directed edges that have the same label are established for the data object based on the same reference attribute metadata; (emphasis added)").
the second instruction identifies a first object name (Chen, Paragraph [0064], “the basic information of the data object template includes a unique data object template identifier, a data object template name, a type of the data object and a data object template description information; (emphasis added)”);
Chen is considered to be analogous to the claimed invention because it is in the same field of object-oriented software development. Therefore, it would have been obvious to someone of ordinary skill in the art before the effective filing date of the claimed invention to have modified Feng to incorporate the teachings of Chen to have:
wherein: the object-management function is a create function
the first data type defines at least one data element; the first instruction includes an initial value for the at least one data element;
the second instruction identifies a first object name;
the method further comprising instantiating the first object with the first object name and the initial value accessed from the second object
The modification would be obvious because one of ordinary skill in the art would be motivated to incorporate template-based creation techniques to flexibly create data objects using object names, initial values, and object relationships (Chen, Paragraph [0005, 0018-0019]).
The combination of Feng and Chen fails to teach:
the second object is instantiated including the initial value for the at least one data element; and
However, Webb teaches:
the second object is instantiated including the initial value for the at least one data element; and (Webb, Column 2, Lines 49-52, “At runtime, a type creation function is called to create in the first process a first instance of a type object describing the data type. The type object has a set of associated functions for processing data having the data type”. Webb, Claim 1, “the first process including a request to send to the second process data having a data type; calling at runtime a type creation function to create a first type object describing the data type, the first type object having a set of associated functions for processing data, the set of associated functions including a marshalling function for encoding data and an unmarshalling function for decoding data; executing the marshalling function in the first process to generate encoded data, the marshalling function executed in the first process taking as input the data and the first type object; communicating the encoded data to the second process; and executing the unmarshalling function on the encoded data to decode the encoded data in the second process.”)
Webb is considered to be analogous to the claimed invention because it is in the same field of object-oriented software development. Therefore, it would have been obvious to someone of ordinary skill in the art before the effective filing date of the claimed invention to have modified Feng to incorporate the teachings of Webb to have:
the second object is instantiated including the initial value for the at least one data element; and
The modification would be obvious because one of ordinary skill in the art would be motivated to incorporate a runtime-created type object [support object] (Webb, Column 2, Lines 43-65) so that object-management operations could use a type object [support object] to process and affect the object at runtime (Webb, Column 2, Lines 22-42).
Regarding Claim 9, the rejection of Claim 7 is incorporated. Feng fails to teach:
wherein: the object-management function is an update function;
the first data type defines at least one data element; the first instruction includes an update value for the at least one data element of the first object;
the method further comprising updating the first object with the update value accessed from the second object.
However, Chen teaches:
wherein: the object-management function is an update function (Chen, Paragraph [0016-0018], "In an embodiment, the step (S102) is performed through a step of: based on the basic attribute metadata and the reference attribute metadata defined by the data object template, operating a data object entity and a data object directed edge to complete creation, update and deletion of the data object;”, Chen, Paragraph [0020], “the update of the data object comprises:”);
the first data type defines at least one data element; the first instruction includes an update value for the at least one data element of the first object; (Chen, Paragraph [0009-0010], “(S101) constructing and storing a data object template comprising an attribute tuple; and (S102) reading a data object template into a memory, and managing storage, update, query and deletion of the data object based on the data object template.”)
the method further comprising updating the first object with the update value accessed from the second object (Chen, Paragraph [0020-0021], “the update of the data object comprises: updating the data object entity or the data object directed edge based on the data object template constructed in step (S101), where the data object entity is updated by updating a value of a key-value pair of the data object entity based on the basic attribute metadata contained in the data object template constructed in step (S101); and the data object directed edge is updated by updating a direction of the data object directed edge based on the reference attribute metadata contained in the data object template constructed in step (S101) or adding a data object directed edge that has the same label and points to other data object entities;”)
Chen is considered to be analogous to the claimed invention because it is in the same field of object-oriented software development. Therefore, it would have been obvious to someone of ordinary skill in the art before the effective filing date of the claimed invention to have modified Feng to incorporate the teachings of Chen to have:
wherein: the object-management function is an update function;
the first data type defines at least one data element; the first instruction includes an update value for the at least one data element of the first object;
the method further comprising updating the first object with the update value accessed from the second object.
The modification would be obvious because one of ordinary skill in the art would be motivated to incorporate template-based creation techniques to flexibly create data objects using object names, initial values, and object relationships (Chen, Paragraph [0005, 0018-0019]).
The combination of Feng and Chen fails to teach:
the second object is instantiated including the update value for the at least one data element of the first object; and
However, Webb teaches:
the second object is instantiated including the update value for the at least one data element of the first object; and (Webb, Claim 1, “calling at runtime a type creation function to create a first type object describing the data type, the first type object having a set of associated functions for processing data, the set of associated functions including a marshalling function for encoding data and an unmarshalling function for decoding data; executing the marshalling function in the first process to generate encoded data, the marshalling function executed in the first process taking as input the data and the first type object; communicating the encoded data to the second process; and executing the unmarshalling function on the encoded data to decode the encoded data in the second process.”, Webb, Paragraph (21), “In this implementation, the corresponding decoding or unmarshalling function first decodes the encoded type descriptors, and uses these decoded descriptors to reassemble the encoded parameter values in remote server process 150's address space.”)
══════════════════════════════════════════════
Examiner's Remarks: As discussed regarding claim 7, Webb teaches a runtime-created type object used to process data, where the marshalling function takes as input the data and the type object, and the unmarshalling functions uses decoded type descriptors to reassemble encoded parameter values. Thus, in the combination, the update value processed using Webb’s type object [support object] is used in Chen’s update operation to update the data object.
══════════════════════════════════════════════
Webb is considered to be analogous to the claimed invention because it is in the same field of object-oriented software development. Therefore, it would have been obvious to someone of ordinary skill in the art before the effective filing date of the claimed invention to have modified Feng to incorporate the teachings of Webb to have:
the second object is instantiated including the update value for the at least one data element of the first object; and
The modification would be obvious because one of ordinary skill in the art would be motivated to incorporate a runtime-created type object [support object] (Webb, Column 2, Lines 43-65) so that object-management operations could use a type object [support object] to process and affect the object at runtime (Webb, Column 2, Lines 22-42).
Regarding Claim 10, the rejection of Claim 7 is incorporated. Feng fails to teach:
the object-management function is a delete function;
the first instruction identifies the first object having an identity;
[…] storing the identity; and
deleting the first object with the identity accessed from the second object.
However, Chen teaches:
the object-management function is a delete function; (Chen, Paragraph [0016-0018], "In an embodiment, the step (S102) is performed through a step of: based on the basic attribute metadata and the reference attribute metadata defined by the data object template, operating a data object entity and a data object directed edge to complete creation, update and deletion of the data object;”, Chen, Paragraph [0022], “the deletion of the data object comprises:”)
the first instruction identifies the first object having an identity (Chen, Paragraph [0092], “Referring to FIG. 6, the data object with a unique data object identifier of 200001 is deleted (emphasis added).”);
[…] storing the identity; and (Chen, Paragraph [0011-0013], “In an embodiment, the step (S101) is performed through a step of: constructing and storing a basic information and the attribute tuple of the data object template; wherein the basic information of the data object template comprises a unique data object template identifier, a data object template name, a type of the data object and a data object template description information (emphasis added);)
deleting the first object with the identity accessed from the second object (Chen, Paragraph [0022-0023], “the deletion of the data object comprises: deleting the data object entity, the data object directed edge, and a data object directed edge which indicates that other data object entities point to a deleted data object entity.”).
Chen is considered to be analogous to the claimed invention because it is in the same field of object-oriented software development. Therefore, it would have been obvious to someone of ordinary skill in the art before the effective filing date of the claimed invention to have modified Feng to incorporate the teachings of Chen to have:
the object-management function is a delete function;
the first instruction identifies the first object having an identity;
[…] storing the identity; and
deleting the first object with the identity accessed from the second object.
The modification would be obvious because one of ordinary skill in the art would be motivated to incorporate template-based techniques to flexibly create, delete, and update data objects using object names, initial values, and object relationships (Chen, Paragraph [0005, 0018-0019]).
The combination of Feng and Chen fails to teach:
the second object is instantiated […]
accessing the stored identity from the second object; and
However, Webb teaches:
the second object is instantiated […] (Webb, Column 2, Lines 49-52, “At runtime, a type creation function is called to create in the first process a first instance of a type object describing the data type. The type object has a set of associated functions for processing data having the data type”. Webb, Column 2, Lines 11-14, “The first type object can be a parameterized type object including an element identifying a location in memory and describing a format for the data type based on one or more type parameters in the identified location.”)
accessing the stored identity from the second object; and (Webb, Claim 1, “calling at runtime a type creation function to create a first type object describing the data type, the first type object having a set of associated functions for processing data, the set of associated functions including a marshalling function for encoding data and an unmarshalling function for decoding data; executing the marshalling function in the first process to generate encoded data, the marshalling function executed in the first process taking as input the data and the first type object (emphasis added); communicating the encoded data to the second process; and executing the unmarshalling function on the encoded data to decode the encoded data in the second process.”, Webb, Column 8, Lines 20-25, “In this implementation, the corresponding decoding or unmarshalling function first decodes the encoded type descriptors, and uses these decoded descriptors to reassemble the encoded parameter values in remote server process 150's address space (emphasis added).”)
Webb is considered to be analogous to the claimed invention because it is in the same field of object-oriented software development. Therefore, it would have been obvious to someone of ordinary skill in the art before the effective filing date of the claimed invention to have modified Feng to incorporate the teachings of Webb to have:
the second object is instantiated […]
accessing the stored identity from the second object; and
The modification would be obvious because one of ordinary skill in the art would be motivated to incorporate a runtime-created type object [support object] (Webb, Column 2, Lines 43-65) so that object-management operations could use a type object [support object] to process and affect the object at runtime (Webb, Column 2, Lines 22-42).
══════════════════════════════════════════════
Examiner's Remarks: As discussed regarding claim 7, Webb teaches a runtime-created type object used to process data, where the type object has associated functions for processing data and decoded descriptors are used to reassemble encoded parameter values. Thus, in the combination, the identity value used in Chen’s delete operation is processed/accessed through Webb’s type object [support object] to delete the data object.
══════════════════════════════════════════════
Regarding Claim 12, the rejection of Claim 11 is incorporated. Feng teaches “additional argument” and Webb teaches “second object” but the combination of Feng and Webb fails to teach:
saving the value for the […] argument accessed from the […] object as metadata associated with the first object.
However, Chen teaches:
saving the value for the […] argument accessed from the […] object as metadata associated with the first object (Chen, Paragraphs [0011-0015], “In an embodiment, the step (S101) is performed through a step of: constructing and storing a basic information and the attribute tuple of the data object template; wherein the basic information of the data object template comprises a unique data object template identifier, a data object template name, a type of the data object and a data object template description information; the attribute tuple comprises at least one attribute metadata; each of the at least one attribute metadata comprises a unique attribute metadata identifier, a unique attribute metadata type, a unique attribute metadata name, a unique attribute metadata value rule, a unique attribute metadata default value and a unique attribute metadata description information;”).
Chen is considered to be analogous to the claimed invention because it is in the same field of object-oriented software development. Therefore, it would have been obvious to someone of ordinary skill in the art before the effective filing date of the claimed invention to have modified Feng to incorporate the teachings of Chen to have:
saving the value for the […] argument accessed from the […] object as metadata associated with the first object.
The modification would be obvious because one of ordinary skill in the art would be motivated to store and manage object-related values as attributes [metadata]. (Chen, Paragraph [0049]). Thus, it would have been obvious to store the additions operation-specific argument when the evaluated condition [expression] indicates the value is permissible, so that the value can be used in later object management operations.
Claim 14 is rejected under 35 U.S.C. 103 as being unpatentable over Feng (US Patent Application Publication No. US 2016/0077853 A1) in view of Kvinge (US Patent No. US 9,201,637 B1) and Webb (US Patent No. US 6,842,786 B1).
Regarding Claim 14, Feng teaches:
[…] a data type for defining a first object (Feng, Claim 1, “the association allows an object instantiator to instantiate the object from the behavioral description in the JS file and the property description in the JSON file.”),
[…] the object-management construct identifying an object-management function for affecting the first object (Feng, Paragraph [0016-0017], “In some embodiments, the framework pre-defines one set of functions for each object that is instantiated from each model. For instance, in some embodiments, each JS object can perform the CRUD functions. The framework of some embodiments allows additional functions to be written in the JS file in order to augment and override the set of functions of an object that is instantiated from the JS file. These additional functions can be written as hooks (e.g., function calls that are processed before or after a baseline function) that can be processed locally (e.g., on a client device) or remotely (e.g., on the server).”);
Feng fails to teach:
A method of compiling source code having […],
encountering in the source code an […] construct directed to the data type […]
emitting a second type for defining an object-management support object associated with the […] function and the data type;
compiling the […] construct into type-specific instructions for accessing […] instructions operable with the object-management support object; and
emitting the […] instructions operable with the type-specific instructions and object-management support object to affect the […] object at runtime.
However, Kvinge teaches:
A method of compiling source code having […] (Kvinge, Column 15, Lines 8-20, “In at least one of the various embodiments, source code 502 may represent one or more files, documents, or resources, for a software application or one or more portions of a software application. In at least one of the various embodiments, source code 502 may include one or more files of human readable/editable source code composed in one or more computer programming languages. Source code 502 may include instructions for performing one or more specific actions (a computer program) on a processor device, such as, processor 202, processor 302, or the like. In at least one of the various embodiments, compiler 504 may represent one or more applications used for generating machine code 506 from provided source code, such as, source code 502.”),
Feng teaches the “object-management construct” but fails to teach:
encountering in the source code an […] construct directed to the data type […]
However, Kvinge teaches:
encountering in the source code an […] construct directed to the data type […] (Kvinge, Column 19, Lines 55-57, “during compilation the compiler may encounter a generic type in the source code of the managed application.” Kvinge, Column 20, Lines 1-6, “At block 804, in at least one of the various embodiments, the compiler may generate machine code based on the generic type. In at least one of the various embodiments, for each encountered generic type the compiler may take additional steps and/or generate additional machine code to handle each generic type.”),
══════════════════════════════════════════════
Examiner's Remarks: Kvinge teaches encountering a source-code construct/type and generating additional machine code. Feng teaches a model framework where each JS object can perform the CRUD functions and additional functions can be written as hooks before or after the baseline function thus making it an object management construct.
══════════════════════════════════════════════
Feng teaches “object-management function”, but fails to teach:
emitting a second type for defining an object-management support object associated with the […] function and the data type;
However, Kvinge teaches:
emitting a second type for defining an […] object associated with the […] function and the data type (Kvinge, Column 18, Lines 16-23, “In code block 612 and code block 614 the compiler has expanded the specific closed generic types that are needed as indicated by the source code. Accordingly, if the source code used other generic types, they would also be expanded. Also, note that in code block 612 and code block 614 the compiler has generated methods with parameter types and return value types that correspond to the type T that is used for each specific closed generic type.”);
Feng teaches the “object-management construct” and “object-management instructions” but fails to teach:
compiling the […] construct into type-specific instructions for accessing […] instructions operable with the object-management support object; and
However, Kvinge teaches:
compiling the […] construct into type-specific instructions for accessing […] instructions operable with the […] object; and (Kvinge, Column 18, Lines 4-6, “In at least one of the various embodiments, as the compiler encounters code block 606 and code block 608 it may generate machine code for handling those specific generic types.” Kvinge, Column 18, Lines 31-35, “Though the compiler will still generate machine code to expand the generic types similar to code block 612 and/or code block 614 for use by the managed runtime environment to execute the managed application.” Kvinge, Column 20, Lines 1-6, “At block 804, in at least one of the various embodiments, the compiler may generate machine code based on the generic type. In at least one of the various embodiments, for each encountered generic type the compiler may take additional steps and/or generate additional machine code to handle each generic type. (emphasis added)”)
Feng teaches “object-management instructions” and “first object” but fails to teach:
emitting the […] instructions operable with the type-specific instructions and object-management support object to affect the […] object at runtime.
However, Kvinge teaches:
emitting the […] instructions operable with the type-specific instructions and […] object to affect the first object at runtime (Kvinge, Column 6, Lines 22-31, “In at least one of the various embodiments, binding layer machine code may be generated that maps each native runtime signature to a corresponding generic type method. In at least one of the various embodiments, generating the binding layer machine code may include generating machine code that may enable one or more managed generic type objects to execute one or more native object methods in the native runtime environment. And, in at least one of the various embodiments, the binding layer machine code may be inserted into the machine code version of the application.”).
══════════════════════════════════════════════
Examiner's Remarks: Kvinge teaches type-specific compiled code and associated binding code. Feng teaches runtime object management instructions and hooks called before or after API processing. The combined system supports compiling the object management constructs into type-specific instructions that access object management instructions.
══════════════════════════════════════════════
Kvinge is considered to be analogous to the claimed invention because it is in the same field of object-oriented software development. Therefore, it would have been obvious to someone of ordinary skill in the art before the effective filing date of the claimed invention to have modified the teachings of Feng to incorporate the teachings of Kvinge to have:
A method of compiling source code having […]
encountering in the source code an […] construct directed to the data type […]
emitting a second type for defining an […] object associated with the […] function and the data type
compiling the […] construct into type-specific instructions for accessing […] instructions operable with the […] object; and
emitting the […] instructions operable with the type-specific instructions and […] object to affect the first object at runtime
The modification would be obvious because one of ordinary skill in the art would be motivated “to managing generic objects across multiple runtime environments” (Kvinge, Column 1, Lines 6-9).
The combination of Feng and Kvinge fails to teach:
[…] object-management support object […]
However, Webb teaches:
[…] object-management support object […] (“Webb, Column 2, Lines 49-52, “At runtime, a type creation function is called to create in the first process a first instance of a type object [support object] describing the data type. The type object has a set of associated functions for processing data having the data type [object-management support]. (emphasis added)”. Webb, Column 2, Lines 11-14, “The first type object [support object] can be a parameterized type object including an element identifying a location in memory and describing a format for the data type based on one or more type parameters in the identified location. (emphasis added)”)
Webb is considered to be analogous to the claimed invention because it is in the same field of object-oriented software development. Therefore, it would have been obvious to someone of ordinary skill in the art before the effective filing date of the claimed invention to have modified Feng to incorporate the teachings of Webb to have:
[…] object-management support object […]
The modification would be obvious because one of ordinary skill in the art would be motivated to incorporate a runtime-created type object [support object] (Webb, Column 2, Lines 43-65) so that object-management operations could use a type object [support object] to process and affect the object at runtime (Webb, Column 2, Lines 22-42).
══════════════════════════════════════════════
Examiner's Remarks: Kvinge teaches compiler-emitted type-specific structure. Webb supports the idea that a separate type object can describe a data type and be associated with functions for processing data of that type. The claimed [second type] corresponds to the compiler generated type specific construct in Kvinge, used to define a support object analogous to Webb's type object.
══════════════════════════════════════════════
Conclusion
The prior art made of record and not relied upon is considered pertinent to applicant's disclosure. They are as follows:
Wang (US 5,940,616 A) discloses a method, apparatus, and article of manufacture for providing object tracking capabilities in object-oriented programming environments using a tracker class and associated functions, and a memory for storing tracker objects.
Matthew (US 2016/0124722 A1) discloses systems and methods for specifying transformations of JSON objects using other JSON objects.
Any inquiry concerning this communication or earlier communications from the examiner should be directed to MD KAMRUZZAMAN whose telephone number is (571) 272-8415. The examiner can normally be reached Monday-Friday 9:00 am - 5:00 pm.
Examiner interviews are available via telephone, in-person, and video conferencing using a USPTO supplied web-based collaboration tool. To schedule an interview, applicant is encouraged to use the USPTO Automated Interview Request (AIR) at http://www.uspto.gov/interviewpractice.
If attempts to reach the examiner by telephone are unsuccessful, the examiner’s supervisor, Wei Mui can be reached at (571) 272-3708. The fax phone number for the organization where this application or proceeding is assigned is 571-273-8300.
Information regarding the status of published or unpublished applications may be obtained from Patent Center. Unpublished application information in Patent Center is available to registered users. To file and manage patent submissions in Patent Center, visit: https://patentcenter.uspto.gov. Visit https://www.uspto.gov/patents/apply/patent-center for more information about Patent Center and https://www.uspto.gov/patents/docx for information about filing in DOCX format. For additional questions, contact the Electronic Business Center (EBC) at 866-217-9197 (toll-free). If you would like assistance from a USPTO Customer Service Representative, call 800-786-9199 (IN USA OR CANADA) or 571-272-1000.
/M.K./Examiner, Art Unit 2191 /WEI Y MUI/Supervisory Patent Examiner, Art Unit 2191
Prosecution Insights