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 .
This action is responding to the amendment filed on 4/2/2026.
Claims 1-14 are pending in the application.
The objection and rejection under 35 U.S.C.101 are withdrawn due to the amendment to the claims.
Claim Rejections - 35 USC § 103
In the event the determination of the status of the application as subject to AIA 35 U.S.C. 102 and 103 (or as subject to pre-AIA 35 U.S.C. 102 and 103) is incorrect, any correction of the statutory basis (i.e., changing from AIA to pre-AIA ) for the rejection will not be considered a new ground of rejection if the prior art relied upon, and the rationale supporting the rejection, would be the same under either status.
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-3, 5-8, and 10-14 are rejected under 35 U.S.C. 103 as being unpatentable over Benton (US20180246708) in view of Sho (JP 2003280899, cited).
Per claim 1:
Benton discloses: A non-transitory computer-readable storage medium with an executable development program stored thereon, the development program being for development of an application program with a programming language in which an object is generated based on a type, the development program comprising instructions for an analysis module and a code generating module, the development program when executed, causes one or more processors of an information processing apparatus to perform: identifying, using a lexical analysis provided by the analysis module, a type definition in a first version of source code of the application program; (Benton, see at least [0005] In another example, a computing device is provided. The computing device includes a memory, and a processor device coupled to the memory. The processor device is to receive a plurality of source code instructions in a computer programming language that includes a data object definition associated with a data object type and a plurality of function definitions that accesses a data object of the data object type. The processor device is further to generate, based on the plurality of function definitions, a corresponding plurality of intermediate functions, each intermediate function comprising a plurality of intermediate code instructions; [0022]; [0035] in this case data objects of the type defined by the data object definitions 62-1-62-5, received and/or returned by the intermediate functions 70; [0044] receives the plurality of source code instructions 60 in a computer programming language that includes data object definitions 62-1-62-5 associated with the data object types A-E, and the plurality of function definitions 64-1-64-5 that accesses data objects of the data object types A-E (FIG. 3, block 1000); [0047]; [0051] A number of modules can be stored in the storage device 114 and in the volatile memory 110, including an operating system 116 and one or more program modules, such as the first stage compiler 12 and the second stage compiler 14);
and generating automatically, using the code generating module, code, the code generated generates an intermediate object for asset data corresponding to each of objects generated based on the identified type definition, and the intermediate object is generated using the generated code while the application program is executed and the intermediate object is stored as the asset data (Benton, see at least [0024] The first stage compiler 12 includes a data object serialization generator 24 that operates to generate data object serializers 26, 30 that are configured to serialize a data object of the corresponding data object type into a data object stream. In this example, based on the data object definition 20-1, the first stage compiler 12 automatically generates a data object serializer 26 that comprises intermediate code instructions configured to serialize a data object of the data object type defined by the data object definition 20-1. The intermediate code instructions are in an intermediate representation (IR) that is suitable for analysis. A program, or function, in the IR has the same meaning as the source code instructions 18 it was generated from, but has been converted into a simpler form that is easier to analyze; [0046], first stage compiler ……the second stage compilers; [0034] A data object serialization generator 24-1, based on the data object definitions 62-1-62-5, automatically generates a plurality of data object serializers 66-1-66-5, each of which comprises intermediate code instructions configured to serialize a data object of the data object type defined by the corresponding data object definition 62-1-62-5 into a data object stream. The data object serialization generator 24-1, based on the data object definitions 62-1-62-5, also automatically generates a plurality of data object deserializers 68-1-68-5, each of which comprises intermediate code instructions configured to deserialize a data object stream into a data object of the data object type defined by the corresponding data object definition 62-1-62-5; [0025]; [0035] An intermediate code instruction generator 34-1 generates, based on the plurality of function definitions 64-1-64-5, a corresponding plurality of intermediate functions 70-1-70-5 (generally, intermediate functions 70), each intermediate function 70 comprising a plurality of intermediate code instructions that implement the function defined by the corresponding function definition 64).
Benton discloses that the generated intermediate functions of the data object serializers result in generation of native source code instruction sets during a second stage compilation ([0034]; [0035]; [0044]; [0047]) which can indicate that the generated source code instruction sets incorporate the generated intermediate functions. However, Benton does not explicitly teach code including a character string, adding the code generated to the first version of the source code of the application program in which the type definition was identified and outputting computer readable files, where the first version of source code is editable by a user to generate second version of the source code including editing the type definition, where the code generated is editable by a user. Sho teaches code including a character string, adding the code generated to the first version of the source code of the application program in which the type definition was identified and outputting computer readable files, where the first version of source code is editable by a user to generate second version of the source code including editing the type definition, where the code generated is editable by a user (Sho, see at least Fig. 5 and associated texts, the data type schema converted into the tree structure by the data type schema analyzing means 21 is judged by the data type name judging means 22 whether or not the end is "_enum" ( Step S1); Fig. 1-9 and associated texts, A data type schema analysis means 32 analyzes the schema defined by the XML processor and converts it into internal data. The schema itself is merely a character string, but this is converted into an internal tree structure; Fig. 1, 2, and 10 and associated texts show a UI (Graphic User Interface) to interactively generate a data type schema and a default value for the data type can be specified by the user via the GUI, the data type schema analysis means 21 using XML).
It would have been obvious for one having ordinary skill in the art before the effective filing date of the claimed invention to have combined Sho’s XML schema text driving code generation and a user editability with Benton’s code generation for serialization to modify Benton’s system to combine the functionalities as taught by Sho, with a reasonable expectation of success, since they are analogous art because they are from the same field of endeavor related to code development or serialization. Combining Sho’s functionality with that of Benton results in a system that allows embedding string literals into an internal structure and adding code and code edit by a user. The modification would be obvious because one having ordinary skill in the art would be motivated to make this combination to allow parsing character string into an internal structure to build an intermediate object for serialization representation for type independence and code edit by a user including code injection by a user (Sho, see at least Fig. 5 and associated texts, the data type schema converted into the tree structure by the data type schema analyzing means 21 is judged by the data type name judging means 22 whether or not the end is "_enum" ( Step S1); Fig. 1-9 and associated texts, A data type schema analysis means 32 analyzes the schema defined by the XML processor and converts it into internal data. The schema itself is merely a character string, but this is converted into an internal tree structure; Fig. 1, 2, and 10 and associated texts show a UI (Graphic User Interface) to interactively generate a data type schema and a default value for the data type can be specified by the user via the GUI, the data type schema analysis means 21 using XML).
Per claim 2:
Benton further teaches: The non-transitory computer-readable storage medium according to claim 1, wherein the development program further causes the one or more processors to add a serialization definition description to the type definition the first version of the source code of the application program, and the intermediate object is generated in accordance with the serialization definition (Benton, see at least [0025] The data object serialization generator 24 also operates to generate intermediate data object deserializers 28, 32 that are configured to deserialize a data object stream into a data object of the data object type. … ; [0034] A data object serialization generator 24-1, based on the data object definitions 62-1-62-5, automatically generates a plurality of data object serializers 66-1-66-5, each of which comprises intermediate code instructions configured to serialize a data object of the data object type defined by the corresponding data object definition 62-1-62-5 into a data object stream; Note that the data object serialization generator 24 generates the data object serializer 26 and the data object deserializer 28 automatically).
Per claim 3:
Benton further teaches: The non-transitory computer-readable storage medium according to claim 2, wherein a portion of the code for the type of the intermediate object is defined independently of the type definition in a corresponding source code (Benton, see at least [0021] domain-specific language programs exist independently of host-language programs. In some examples, the source code instructions 18 are in an embedded domain specific language and can be used in conjunction with other programming languages; [0025] The data object serialization generator 24 also operates to generate intermediate data object deserializers 28, 32 that are configured to deserialize a data object stream into a data object of the data object type. In this example, based on the data object definition 20-1, the first stage compiler 12 automatically generates a data object deserializer 28 that comprises intermediate code instructions configured to deserialize a data object stream into a data object of the data object type defined by the data object definition 20-1. [0035] An intermediate code instruction generator 34-1 generates, based on the plurality of function definitions 64-1-64-5, a corresponding plurality of intermediate functions 70-1-70-5 (generally, intermediate functions 70), each intermediate function 70 comprising a plurality of intermediate code instructions that implement the function defined by the corresponding function definition 64; Note that the data object serialization generator 24 generates the data object serializer 26 and the data object deserializer 28 automatically).
Per claim 5:
Benton further teaches: The non-transitory computer-readable storage medium according to claim 2, wherein the development program further causes the one or more processors to add a code to the type definition in the first version of the source code of the application program for performing processing for calling processing for holding in the intermediate object, a value obtained by a function designated in advance or a value designated in advance (Benton, see at least [0020] The source code instructions 18 include one or more data object definitions 20-1, 20-2 (generally, data object definitions 20), and a plurality of function definitions 22-1-22-N (generally, function definitions 22). … the data object definitions 20 may comprise: scalar numeric types … i.e., unordered collections of distinct values, with the set type parameterized by the element type … the head is a value of X and the tail is a list of X, and the empty list is a 0-arity tuple; [0022] a function definition 22 may include a function name, a function type, and a function body. Function names may be arbitrary identifiers used to refer to functions elsewhere in a program. Function types include the input types for each function argument and the result type of the function; for example, “max”, a function to identify the largest of two integers might have the type (Int, Int)->Int, indicating that the max function takes two integer values and returns one integer value. A function body may be an expression).
Per claim 6:
Benton further discloses:
The non-transitory computer-readable storage medium according to claim 2, wherein the development program further causes the one or more processors to add a code to the type definition in the first version of the source code of the application program for performing processing for calling processing for passing a value of a property held in the intermediate object to a function designated in advance (Benton, see at least [0022] The function definitions 22 implement desired behavior. By way of non-limiting examples, and in particular in a machine learning context, a function definition 22 may include a function name, a function type, and a function body. Function names may be arbitrary identifiers used to refer to functions elsewhere in a program. Function types include the input types for each function argument and the result type of the function; for example, “max”, a function to identify the largest of two integers might have the type (Int, Int)->Int, indicating that the max function takes two integer values and returns one integer value; Note that the primitive data type, Int arguments are passed to a function/method by value).
7. The non-transitory computer-readable storage medium according to claim 2, wherein the development program further causes the one or more processors to add a code to the type definition in the first version of the source code of the application program for performing processing for calling processing for outputting a value of a property of the intermediate object in a predetermined format for each type of the intermediate object (Benton, see at least [0032], The function V outputs a data object defined by the data object definition 62-4 (i.e., a data object of type D). A function W (defined by the function definition 64-2) receives, as input, a data object defined by the data object definition 62-2 (i.e., a data object of type B). The function W outputs a data object defined by the data object definition 62-5 (i.e., a data object of type E); [0024] A program, or function, in the IR has the same meaning as the source code instructions 18 it was generated from, but has been converted into a simpler form that is easier to analyze).
8. The non-transitory computer-readable storage medium according to claim 1, wherein the identifying a type definition includes extracting, from the first version of the source code of the application program, the serialization definition description including a first description that designates a name of a property and a second description that designates a function or a variable for obtaining a value (Benton, see at least [0020] The data object definitions 20 identify data structures that are utilized by the function definitions 22…. parameterized sum types, or tagged unions, so that a single type may include values with multiple shapes. As an example, a list with elements of X as a sum type could be declared as follows: a list of X is either a cell of X or the empty list, a cell of X is a record with two fields: the head is a value of X and the tail is a list of X, and the empty list is a 0-arity tuple; [0022] a function definition 22 may include a function name, a function type, and a function body… The binding list is a sequence of pairs of variable names and expressions).
Per claim 10, it is the system version of claim 1, and is rejected for the same reasons set forth in connection with the rejection of claim 1 above.
Per claim 11, it is the apparatus version of claim 1, and is rejected for the same reasons set forth in connection with the rejection of claim 1 above.
Per claim 12, it is the method version of claim 1, and is rejected for the same reasons set forth in connection with the rejection of claim 1 above.
Per claim 13:
Benton does not explicitly teach a user interface configured to receive edits to the first version of the source code and the generated code. Sho teaches a user interface configured to receive edits to the first version of the source code and the generated code. (Sho, see at least Fig. 5 and associated texts, the data type schema converted into the tree structure by the data type schema analyzing means 21 is judged by the data type name judging means 22 whether or not the end is "_enum" ( Step S1); Fig. 1-9 and associated texts, A data type schema analysis means 32 analyzes the schema defined by the XML processor and converts it into internal data. The schema itself is merely a character string, but this is converted into an internal tree structure; Fig. 1, 2, and 10 and associated texts show a UI (Graphic User Interface) to interactively generate a data type schema and a default value for the data type can be specified by the user via the GUI, the data type schema analysis means 21 using XML).
It would have been obvious for one having ordinary skill in the art before the effective filing date of the claimed invention to have combined Sho’s user interface for user editability with Benton’s code generation for serialization to modify Benton’s system to combine the functionalities as taught by Sho, with a reasonable expectation of success, since they are analogous art because they are from the same field of endeavor related to code development or serialization. Combining Sho’s functionality with that of Benton results in a system that allows adding code and code edit by a user. The modification would be obvious because one having ordinary skill in the art would be motivated to make this combination to allow code edit by a user including code injection by a user (Sho, see at least Fig. 5 and associated texts, the data type schema converted into the tree structure by the data type schema analyzing means 21 is judged by the data type name judging means 22 whether or not the end is "_enum" ( Step S1); Fig. 1-9 and associated texts, A data type schema analysis means 32 analyzes the schema defined by the XML processor and converts it into internal data. The schema itself is merely a character string, but this is converted into an internal tree structure; Fig. 1, 2, and 10 and associated texts show a UI (Graphic User Interface) to interactively generate a data type schema and a default value for the data type can be specified by the user via the GUI, the data type schema analysis means 21 using XML).
Per claim 14:
Benton does not explicitly teach wherein the development program further causes the one or more processors to generate a schema file based on the identified type definition. Sho teaches wherein the development program further causes the one or more processors to generate a schema file based on the identified type definition (Sho, see at least Fig. 5 and associated texts, the data type schema converted into the tree structure by the data type schema analyzing means 21 is judged by the data type name judging means 22 whether or not the end is "_enum" ( Step S1); Fig. 1-9 and associated texts, A data type schema analysis means 32 analyzes the schema defined by the XML processor and converts it into internal data. The schema itself is merely a character string, but this is converted into an internal tree structure; Fig. 1, 2, and 10 and associated texts show a UI (Graphic User Interface) to interactively generate a data type schema and a default value for the data type can be specified by the user via the GUI, the data type schema analysis means 21 using XML).
It would have been obvious for one having ordinary skill in the art before the effective filing date of the claimed invention to have combined Sho’s XML schema text driving code generation with Benton’s code generation for serialization to modify Benton’s system to combine the functionalities as taught by Sho, with a reasonable expectation of success, since they are analogous art because they are from the same field of endeavor related to code development or serialization. Combining Sho’s functionality with that of Benton results in a system that allows embedding schema string literals into an internal structure. The modification would be obvious because one having ordinary skill in the art would be motivated to make this combination to allow parsing character string into an internal structure to build an intermediate object for serialization representation for type independence (Sho, see at least Fig. 5 and associated texts, the data type schema converted into the tree structure by the data type schema analyzing means 21 is judged by the data type name judging means 22 whether or not the end is "_enum" ( Step S1); Fig. 1-9 and associated texts, A data type schema analysis means 32 analyzes the schema defined by the XML processor and converts it into internal data. The schema itself is merely a character string, but this is converted into an internal tree structure; Fig. 1, 2, and 10 and associated texts show a UI (Graphic User Interface) to interactively generate a data type schema and a default value for the data type can be specified by the user via the GUI, the data type schema analysis means 21 using XML).
Claim 4 is rejected under 35 U.S.C. 103 as being unpatentable over Benton in view of Sho and Stairs et al. (US 20170337038, hereafter Stairs).
Per claim 4:
Benton does not explicitly teach wherein in the serialization definition description, the type of the intermediate object is defined to inherit a common type definition. Stairs teaches wherein in the second code, the type of the intermediate object is defined to inherit a common type definition (Stairs, see at least [0003] Although separate classes can be defined for each vehicle type, each class defining data members for the common attributes along with data members for the vehicle type-specific attributes, OOP inheritance allows the common attributes to be defined once and then inherited by the vehicle type-specific classes. The Vehicle class defines the data members and methods that are common to all vehicles. The inheritance of the Vehicle class by a Car class). It would have been obvious for one having ordinary skill in the art before the effective filing date of the claimed invention to have combined Stairs’ OOP inheritance with Benton’s code generation for serialization and Sho’s schema character string and UI to modify Benton’s system to combine the inheritance function as taught by Stairs, with a reasonable expectation of success, since they are analogous art because they are from the same field of endeavor related to code development or serialization. Combining Stairs’ functionality with that of Benton and Sho results in a system that allows common type definition inheritance. The modification would be obvious because one having ordinary skill in the art would be motivated to make this combination to allow common attributes to be defined once and then inherited by type specific classes (Stairs, see at least [0003] Although separate classes can be defined for each vehicle type, each class defining data members for the common attributes along with data members for the vehicle type-specific attributes, OOP inheritance allows the common attributes to be defined once and then inherited by the vehicle type-specific classes. The Vehicle class defines the data members and methods that are common to all vehicles. The inheritance of the Vehicle class by a Car class).
Claim 9 is rejected under 35 U.S.C. 103 as being unpatentable over Benton in view of Sho and Yoshinori (JP2018032154, cited).
Per claim 9:
Benton does not explicitly teach wherein the development program further causes the one or more processors to add another code that performs processing for holding a history of the intermediate object to the source code of the application program. Yoshinori teaches wherein the development program further causes the one or more processors to add a third code that performs processing for holding a history of the intermediate object to the source code of the application program (Yoshinori, see at least page 2, A conventional serializer cannot collectively deserialize a whole class, because it does not hold the class definition of an old version. A serializer of the present invention prepares a conversion program between any version and a previous version, repeats version up/down conversion, and hence can achieve storage/recovery of class/instance in all versions. In the present invention, the class definition of the old version is held, so that a conventional serializer technology can be applied also to a class of a previous version). It would have been obvious for one having ordinary skill in the art before the effective filing date of the claimed invention to have combined Yoshinori’s holding a history of conversions with Benton’s code generation for serialization and Sho’s schema character string and UI to modify Benton’s system to combine the inheritance function as taught by Stairs, with a reasonable expectation of success, since they are analogous art because they are from the same field of endeavor related to code development or serialization. Combining Yoshinori’s functionality with that of Benton and Sho results in a system that allows code conversion history holding. The modification would be obvious because one having ordinary skill in the art would be motivated to make this combination to allow storage/recovery of class/instance in all versions (Yoshinori, see at least Page 2, A conventional serializer cannot collectively deserialize a whole class, because it does not hold the class definition of an old version. A serializer of the present invention prepares a conversion program between any version and a previous version, repeats version up/down conversion, and hence can achieve storage/recovery of class/instance in all versions. In the present invention, the class definition of the old version is held, so that a conventional serializer technology can be applied also to a class of a previous version).
Examiner’s Note
The Examiner has pointed out particular references contained in the prior art of record within the body of this action for the convenience of the Applicant. Although the specified citations are representative of the teachings in the art and are applied to the specific limitations within the individual claim, other passages and figures may apply. Applicant, in preparing the response, should consider fully the entire reference as potentially teaching all or part of the claimed invention, as well as the context of the passage as taught by the prior art or disclosed by the Examiner.
Response to Arguments
Applicant’s arguments with respect to claim(s) 1-14 have been considered but are moot because the new ground of rejection does not rely on any reference applied in the prior rejection of record for any teaching or matter specifically challenged in the argument.
Conclusion
Applicant's amendment necessitated the new ground(s) of rejection presented in this Office action. Accordingly, THIS ACTION IS MADE FINAL. See MPEP § 706.07(a). Applicant is reminded of the extension of time policy as set forth in 37 CFR 1.136(a).
A shortened statutory period for reply to this final action is set to expire THREE MONTHS from the mailing date of this action. In the event a first reply is filed within TWO MONTHS of the mailing date of this final action and the advisory action is not mailed until after the end of the THREE-MONTH shortened statutory period, then the shortened statutory period will expire on the date the advisory action is mailed, and any nonprovisional extension fee (37 CFR 1.17(a)) pursuant to 37 CFR 1.136(a) will be calculated from the mailing date of the advisory action. In no event, however, will the statutory period for reply expire later than SIX MONTHS from the mailing date of this final action.
The prior art made of record and not relied upon is considered pertinent to applicant's disclosure.
JP 2005310171 is related to code generation based on data type definition included in an interface definition.
Any inquiry concerning this communication or earlier communications from the examiner should be directed to INSUN KANG whose telephone number is (571)272-3724. The examiner can normally be reached M-TR 9am-5pm.
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, Chat Do can be reached at 571-272-3721. 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.
/INSUN KANG/ Primary Examiner, Art Unit 2193
Prosecution Insights