DETAILED ACTION
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 .
Information Disclosure Statement
The information disclosure statement (IDS) submitted on 06/10/2024 is in compliance with the provisions of 37 CFR 1.97. Accordingly, the information disclosure statement is being considered by the examiner.
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-20 are rejected under 35 U.S.C. 101 because the claimed invention is directed to an abstract idea without significantly more.
Regarding Claim 1,
Claim 1 is rejected under 35 U.S.C. 101 because the claimed invention is directed to an abstract idea without significantly more.
Step 1 Analysis: Claim 1 is directed to a method, which is directed to a process, one of the statutory categories.
Step 2A Prong One Analysis: The limitations:
“generating, …, an Extensible Markup Language Metadata Interchange (XMI) representation of a Unified Modeling Language (UML) model corresponding to an architecture solution based on a set of instructions in a predefined format”
“generating, …, the UML model corresponding to the architecture solution based on the XMI representation of the UML model”
As drafted, under their broadest reasonable interpretations, cover mental processes (concepts performed in the human mind (including an observation, evaluation, judgement, opinion)) but for the recitation of mere instructions to apply language (See MPEP 2106.05(f)). The above limitations in the context of this claim encompass generating an XMI representation of a UML model corresponding to an architecture solution based on a set of instructions in a predefined format (corresponds to evaluation and judgement; in particular, a human, with the assistance of pen and paper, can generate an XMI representation of a UML model corresponding to an architecture solution based on a set of instructions in a predefined format); and generating the UML model corresponding to the architecture solution based on the XMI representation of the UML model (corresponds to evaluation and judgement; in particular, a human, with the assistance of pen and paper, can, based on the XMI representation of the UML model, generate the UML corresponding to the architecture solution).
Step 2A Prong Two Analysis: The judicial exceptions are not integrated into a practical application. In particular, the claim recites additional elements that are mere instructions to apply (See MPEP 2106.05(f)). The limitations:
“a computer”
“by the computer”
As drafted, are additional elements that amount to no more than mere instructions to apply the exception for the abstract ideas. See MPEP 2106.05(f). Therefore, the additional elements do not integrate the abstract ideas into a practical application.
Step 2B Analysis: The claim does not include additional elements that are sufficient to amount to significantly more than the judicial exception. As discussed above with respect to integration of the abstract idea into a practical application, all of the additional elements are “mere instructions to apply an exception” (I.e. the additional elements describe a generic computer for applying the abstract ideas). Mere instructions to apply an exception cannot provide an inventive concept. The claim is not patent eligible.
Regarding Claim 2,
Claim 2 is rejected under 35 U.S.C. 101 because the claimed invention is directed to an abstract idea without significantly more.
Step 1 Analysis: Claim 2 is directed to a method, which is directed to a process, one of the statutory categories.
Step 2A Prong One Analysis: The limitation:
“performing, …, an automated alignment of model elements in UML diagrams of the UML model”
As drafted, under their broadest reasonable interpretations, cover mental processes (concepts performed in the human mind (including an observation, evaluation, judgement, opinion)) but for the recitation of mere instructions to apply language (See MPEP 2106.05(f)). The above limitations in the context of this claim encompass performing an automated alignment of model elements in UML diagrams of the UML model (corresponds to evaluation and judgement; in particular, a human, with the assistance of pen and paper, can perform an automated alignment of model elements in the UML diagrams).
Step 2A Prong Two Analysis: The judicial exceptions are not integrated into a practical application. In particular, the claim recites additional elements that are mere instructions to apply (See MPEP 2106.05(f)). The limitation:
“by the computer”
As drafted, is an additional element that amounts to no more than mere instructions to apply the exception for the abstract ideas. See MPEP 2106.05(f). In addition, the recitation of additional elements in claim 1 of a generic computer, as drafted, are reciting mere instructions to apply language such that it amounts to no more than mere instructions to apply the exceptions. Therefore, the additional elements do not integrate the abstract ideas into a practical application.
Step 2B Analysis: The claim does not include additional elements that are sufficient to amount to significantly more than the judicial exception. As discussed above with respect to integration of the abstract idea into a practical application, all of the additional elements are “mere instructions to apply an exception” (I.e. the additional elements describe a generic computer for applying the abstract ideas). Mere instructions to apply an exception cannot provide an inventive concept. The claim is not patent eligible.
Regarding Claim 3,
Claim 3 is rejected under 35 U.S.C. 101 because the claimed invention is directed to an abstract idea without significantly more.
Step 1 Analysis: Claim 3 is directed to a method, which is directed to a process, one of the statutory categories.
Step 2A Prong One Analysis: The limitations:
“validating, …, the UML model corresponding to the architecture solution based on a set of standard UML model validation rules and a set of UML model validation rules specific to the architecture solution”
“ranking, …, the UML model corresponding to the architecture solution based on a set of principles and standards defined for the architecture solution”
As drafted, under their broadest reasonable interpretations, cover mental processes (concepts performed in the human mind (including an observation, evaluation, judgement, opinion)) but for the recitation of mere instructions to apply language (See MPEP 2106.05(f)). The above limitations in the context of this claim encompass validating the UML model corresponding to the architecture solution based on a set of standard UML model validation rules and a set of UML model validation rules specific to the architecture solution (corresponds to evaluation and judgement; in particular, a human, with the assistance of pen and paper, can use a set of standard UML model validation rules and a set of UML model validation rules specific to the architecture solution to validate the UML model corresponding to the architecture solution); and ranking the UML model corresponding to the architecture solution based on a set of principles and standards defined for the architecture solution (corresponds to evaluation and judgement; in particular, a human, with the assistance of pen and paper, can, based on a set of principles and standards defined for the architecture solution, ranking the UML model corresponding to the architecture solution).
Step 2A Prong Two Analysis: The judicial exceptions are not integrated into a practical application. In particular, the claim recites additional elements that are mere instructions to apply (See MPEP 2106.05(f)). The limitations:
“by the computer”
As drafted, are additional elements that amount to no more than mere instructions to apply the exception for the abstract ideas. See MPEP 2106.05(f). In addition, the recitation of additional elements in claim 1 of a generic computer, as drafted, are reciting mere instructions to apply language such that it amounts to no more than mere instructions to apply the exceptions. Therefore, the additional elements do not integrate the abstract ideas into a practical application.
Step 2B Analysis: The claim does not include additional elements that are sufficient to amount to significantly more than the judicial exception. As discussed above with respect to integration of the abstract idea into a practical application, all of the additional elements are “mere instructions to apply an exception” (I.e. the additional elements describe a generic computer for applying the abstract ideas). Mere instructions to apply an exception cannot provide an inventive concept. The claim is not patent eligible.
Regarding Claim 4,
Claim 4 is rejected under 35 U.S.C. 101 because the claimed invention is directed to an abstract idea without significantly more.
Step 1 Analysis: Claim 4 is directed to a method, which is directed to a process, one of the statutory categories.
Step 2A Prong One Analysis: The limitation:
“generating, …, an XMI representation compatibility report, a UML model validation report, and a UML model rank report for the UML model corresponding to the architecture solution”
As drafted, under their broadest reasonable interpretations, cover mental processes (concepts performed in the human mind (including an observation, evaluation, judgement, opinion)) but for the recitation of mere instructions to apply language (See MPEP 2106.05(f)). The above limitations in the context of this claim encompass generating an XMI representation compatibility report, a UML model validation report, and a UML model rank report for the UML model corresponding to the architecture solution (corresponds to evaluation and judgement; in particular, a human, with the assistance of pen and paper, can, for the UML model corresponding to the architectural solution, generate an XMI representation compatibility report, a UML model validation report, and a UML model rank report).
Step 2A Prong Two Analysis: The judicial exceptions are not integrated into a practical application. In particular, the claim recites additional elements that are mere instructions to apply (See MPEP 2106.05(f)). The limitations:
“by the computer”
“inputting, by the computer, the XMI representation compatibility report, the UML model validation report, and the UML model rank report into a foundation model to retrain the foundation model via self-learning to increase accuracy of generating XMI representations of UML models”
As drafted, are additional elements that amount to no more than mere instructions to apply the exception for the abstract ideas. See MPEP 2106.05(f). In addition, the recitation of additional elements in claim 1 of a generic computer, as drafted, are reciting mere instructions to apply language such that it amounts to no more than mere instructions to apply the exceptions. Therefore, the additional elements do not integrate the abstract ideas into a practical application.
Step 2B Analysis: The claim does not include additional elements that are sufficient to amount to significantly more than the judicial exception. As discussed above with respect to integration of the abstract idea into a practical application, all of the additional elements are “mere instructions to apply an exception” (I.e. the additional elements describe a generic computer and model retraining for applying the abstract ideas). Mere instructions to apply an exception cannot provide an inventive concept. The claim is not patent eligible.
Regarding Claim 5,
Claim 5 is rejected under 35 U.S.C. 101 because the claimed invention is directed to an abstract idea without significantly more.
Step 1 Analysis: Claim 5 is directed to a method, which is directed to a process, one of the statutory categories.
Step 2A Prong One Analysis: Please see the analysis of claim 4. The limitations of claim 5 are only additional elements to the abstract ideas of claim 4.
Step 2A Prong Two Analysis: The judicial exceptions are not integrated into a practical application. In particular, the claim recites additional elements that are mere instructions to apply (See MPEP 2106.05(f)) or insignificant extra-solution activity (See MPEP 2106.05(g)). The limitations:
“by the computer”
“implementing, by the computer, the architecture solution in an environment corresponding to the user in response to receiving an input from the user to implement the architecture solution based on the XMI representation compatibility report, the UML model validation report, and the UML model rank report”
As drafted, are additional elements that amount to no more than mere instructions to apply the exception for the abstract ideas. See MPEP 2106.05(f). The limitation:
“sending, by the computer, the XMI representation compatibility report, the UML model validation report, and the UML model rank report to a user via a client device”
As drafted, is an additional element that corresponds to insignificant extra-solution activity. In particular, the additional elements are merely directed towards mere data gathering. See MPEP 2106.05(g). In addition, the recitation of additional elements in claim 1 of a generic computer and model retraining, as drafted, are reciting mere instructions to apply language such that it amounts to no more than mere instructions to apply the exceptions. Therefore, the additional elements do not integrate the abstract ideas into a practical application.
Step 2B Analysis: The claim does not include additional elements that are sufficient to amount to significantly more than the judicial exception. As discussed above with respect to integration of the abstract idea into a practical application, all of the additional elements are “mere instructions to apply an exception” (I.e. the additional elements describe a generic computer and model retraining for applying the abstract ideas) or insignificant extra-solution activity (i.e. sending/transmitting data). Furthermore, the “sending …” limitation is insignificant extra-solution activity that is well-understood, routine, and conventional according to MPEP 2106.05(d) (“The courts have recognized the following computer functions as well‐understood, routine, and conventional functions when they are claimed in a merely generic manner (e.g., at a high level of generality) or as insignificant extra-solution activity… i. Receiving or transmitting data over a network). Mere instructions to apply an exception cannot provide an inventive concept. The claim is not patent eligible.
Regarding Claim 6,
Claim 6 is rejected under 35 U.S.C. 101 because the claimed invention is directed to an abstract idea without significantly more.
Step 1 Analysis: Claim 6 is directed to a method, which is directed to a process, one of the statutory categories.
Step 2A Prong One Analysis: The limitation:
“verifying, …, compatibility of the XMI representation of the UML model corresponding to the architecture solution with the architecture modeling tool”
As drafted, under their broadest reasonable interpretations, cover mental processes (concepts performed in the human mind (including an observation, evaluation, judgement, opinion)) but for the recitation of mere instructions to apply language (See MPEP 2106.05(f)) and insignificant extra-solution activity (See MPEP 2106.05(g)). The above limitations in the context of this claim encompass verifying compatibility of the XMI representation of the UML model corresponding to the architecture solution with the architecture modeling tool (corresponds to evaluation and judgement; in particular, a human, with the assistance of pen and paper, can verify compatibility of the XMI representation of the UML model corresponding to the architecture solution with the architecture modeling tool).
Step 2A Prong Two Analysis: The judicial exceptions are not integrated into a practical application. In particular, the claim recites additional elements that are mere instructions to apply (See MPEP 2106.05(f)) or insignificant extra-solution activity (See MPEP 2106.05(g)). The limitations:
“by the computer”
As drafted, are additional elements that amount to no more than mere instructions to apply the exception for the abstract ideas. See MPEP 2106.05(f). The limitation:
“importing, by the computer, the XMI representation of the UML model corresponding to the architecture solution into an architecture modeling tool”
As drafted, is an additional element that corresponds to insignificant extra-solution activity. In particular, the additional elements are merely directed towards mere data gathering. See MPEP 2106.05(g). In addition, the recitation of additional elements in claim 1 of a generic computer, as drafted, are reciting mere instructions to apply language such that it amounts to no more than mere instructions to apply the exceptions. Therefore, the additional elements do not integrate the abstract ideas into a practical application.
Step 2B Analysis: The claim does not include additional elements that are sufficient to amount to significantly more than the judicial exception. As discussed above with respect to integration of the abstract idea into a practical application, all of the additional elements are “mere instructions to apply an exception” (I.e. the additional elements describe a generic computer for applying the abstract ideas) or insignificant extra-solution activity (i.e. importing/transmitting data). Furthermore, the “importing …” limitation is insignificant extra-solution activity that is well-understood, routine, and conventional according to MPEP 2106.05(d) (“The courts have recognized the following computer functions as well‐understood, routine, and conventional functions when they are claimed in a merely generic manner (e.g., at a high level of generality) or as insignificant extra-solution activity… i. Receiving or transmitting data over a network). Mere instructions to apply an exception cannot provide an inventive concept. The claim is not patent eligible.
Regarding Claim 7,
Claim 7 is rejected under 35 U.S.C. 101 because the claimed invention is directed to an abstract idea without significantly more.
Step 1 Analysis: Claim 7 is directed to a method, which is directed to a process, one of the statutory categories.
Step 2A Prong One Analysis: The limitations:
“performing, …, an analysis of the set of project-specific architecture solution needs corresponding to the architecture solution received from the user via the client device”
“converting, …, the set of project-specific architecture solution needs corresponding to the architecture solution into the set of instructions in the predefined format based on the analysis of the set of project-specific architecture solution needs”
As drafted, under their broadest reasonable interpretations, cover mental processes (concepts performed in the human mind (including an observation, evaluation, judgement, opinion)) but for the recitation of mere instructions to apply language (See MPEP 2106.05(f)) and insignificant extra-solution activity (See MPEP 2106.05(g)). The above limitations in the context of this claim encompass performing an analysis of the set of project-specific architecture solution needs corresponding to the architecture solution received from the user via the client device (corresponds to evaluation and judgement; in particular, a human, with the assistance of pen and paper, can perform an analysis of the set of project-specific architecture solution needs corresponding to the architecture solution); and converting the set of project-specific architecture solution needs corresponding to the architecture solution into the set of instructions in the predefined format based on the analysis of the set of project-specific architecture solution needs (corresponds to evaluation and judgement; in particular, a human, with the assistance of pen and paper, can, based on the analysis of the set of project-specific architecture solution needs, convert the set of project-specific architecture solution needs corresponding to the architecture solution into the set of instructions in the predefined format).
Step 2A Prong Two Analysis: The judicial exceptions are not integrated into a practical application. In particular, the claim recites additional elements that are mere instructions to apply (See MPEP 2106.05(f)) or insignificant extra-solution activity (See MPEP 2106.05(g)). The limitations:
“by the computer”
“a client device”
“using a foundation model”
As drafted, are additional elements that amount to no more than mere instructions to apply the exception for the abstract ideas. See MPEP 2106.05(f). The limitation:
“receiving, by the computer, a set of project-specific architecture solution needs corresponding to the architecture solution from a user via a client device”
As drafted, is an additional element that corresponds to insignificant extra-solution activity. In particular, the additional elements are merely directed towards mere data gathering. See MPEP 2106.05(g). In addition, the recitation of additional elements in claim 1 of a generic computer, as drafted, are reciting mere instructions to apply language such that it amounts to no more than mere instructions to apply the exceptions. Therefore, the additional elements do not integrate the abstract ideas into a practical application.
Step 2B Analysis: The claim does not include additional elements that are sufficient to amount to significantly more than the judicial exception. As discussed above with respect to integration of the abstract idea into a practical application, all of the additional elements are “mere instructions to apply an exception” (I.e. the additional elements describe a generic computer, client device, and model for applying the abstract ideas) or insignificant extra-solution activity (i.e. receiving data). Furthermore, the “receiving …” limitation is insignificant extra-solution activity that is well-understood, routine, and conventional according to MPEP 2106.05(d) (“The courts have recognized the following computer functions as well‐understood, routine, and conventional functions when they are claimed in a merely generic manner (e.g., at a high level of generality) or as insignificant extra-solution activity… i. Receiving or transmitting data over a network). Mere instructions to apply an exception cannot provide an inventive concept. The claim is not patent eligible.
Regarding Claim 8,
Claim 8 is rejected under 35 U.S.C. 101 because the claimed invention is directed to an abstract idea without significantly more.
Step 1 Analysis: Claim 8 is directed to a method, which is directed to a process, one of the statutory categories.
Step 2A Prong One Analysis: Please see the analysis of claim 7. The limitations of claim 8 are only additional elements to the abstract ideas of claim 7.
Step 2A Prong Two Analysis: The judicial exceptions are not integrated into a practical application. In particular, the claim recites additional elements that are mere instructions to apply (See MPEP 2106.05(f)) or insignificant extra-solution activity (See MPEP 2106.05(g)). The limitation:
“wherein the predefined format is usable by a generative artificial intelligence-based XMI generator and an architecture model automation component of the computer”
As drafted, is an additional element that amounts to no more than mere instructions to apply the exception for the abstract ideas. See MPEP 2106.05(f). The limitations:
“wherein the set of project-specific architecture solution needs corresponding to the architecture solution includes at least one of a system context diagram, an architecture overview diagram, a component diagram, a deployment diagram, a set of functional requirements, and a set on non-functional requirements”
As drafted, is part of the additional element of claim 7 of receiving a set of project-specific architecture solution needs. In addition, the recitation of additional elements in claim 7 of a generic computer, client device, and model, as drafted, are reciting mere instructions to apply language such that it amounts to no more than mere instructions to apply the exceptions. Furthermore, the “receiving …” limitation of claim 7 is an additional element that corresponds to insignificant extra-solution activity as mere data gathering. Therefore, the additional elements do not integrate the abstract ideas into a practical application.
Step 2B Analysis: The claim does not include additional elements that are sufficient to amount to significantly more than the judicial exception. As discussed above with respect to integration of the abstract idea into a practical application, all of the additional elements are “mere instructions to apply an exception” (I.e. the additional elements describe a generic computer, client device, and model for applying the abstract ideas) or insignificant extra-solution activity (i.e. receiving data). Furthermore, the “receiving …” limitations are insignificant extra-solution activity that is well-understood, routine, and conventional according to MPEP 2106.05(d) (“The courts have recognized the following computer functions as well‐understood, routine, and conventional functions when they are claimed in a merely generic manner (e.g., at a high level of generality) or as insignificant extra-solution activity… i. Receiving or transmitting data over a network). Mere instructions to apply an exception cannot provide an inventive concept. The claim is not patent eligible.
Regarding Claim 9,
Claim 9 is rejected under 35 U.S.C. 101 because the claimed invention is directed to an abstract idea without significantly more.
Step 1 Analysis: Claim 9 is directed to a system, which is directed to a machine, one of the statutory categories.
Step 2A Prong One Analysis: The limitations:
“generate an Extensible Markup Language Metadata Interchange (XMI) representation of a Unified Modeling Language (UML) model corresponding to an architecture solution based on a set of instructions in a predefined format”
“generate the UML model corresponding to the architecture solution based on the XMI representation of the UML model”
As drafted, under their broadest reasonable interpretations, cover mental processes (concepts performed in the human mind (including an observation, evaluation, judgement, opinion)) but for the recitation of mere instructions to apply language (See MPEP 2106.05(f)). The above limitations in the context of this claim encompass generating an XMI representation of a UML model corresponding to an architecture solution based on a set of instructions in a predefined format (corresponds to evaluation and judgement; in particular, a human, with the assistance of pen and paper, can generate an XMI representation of a UML model corresponding to an architecture solution based on a set of instructions in a predefined format); and generating the UML model corresponding to the architecture solution based on the XMI representation of the UML model (corresponds to evaluation and judgement; in particular, a human, with the assistance of pen and paper, can, based on the XMI representation of the UML model, generate the UML corresponding to the architecture solution).
Step 2A Prong Two Analysis: The judicial exceptions are not integrated into a practical application. In particular, the claim recites additional elements that are mere instructions to apply (See MPEP 2106.05(f)). The limitations:
“a communication fabric”
“a set of computer-readable storage media connected to the communication fabric, wherein the set of computer-readable storage media collectively stores program instructions”
“a set of processors connected to the communication fabric, wherein the set of processors executes the program instructions”
As drafted, are additional elements that amount to no more than mere instructions to apply the exception for the abstract ideas. See MPEP 2106.05(f). Therefore, the additional elements do not integrate the abstract ideas into a practical application.
Step 2B Analysis: The claim does not include additional elements that are sufficient to amount to significantly more than the judicial exception. As discussed above with respect to integration of the abstract idea into a practical application, all of the additional elements are “mere instructions to apply an exception” (I.e. the additional elements describe a generic communication fabric, computer-readable storage media, and processors for applying the abstract ideas). Mere instructions to apply an exception cannot provide an inventive concept. The claim is not patent eligible.
Regarding Claim 10,
Claim 10 is rejected under 35 U.S.C. 101 because the claimed invention is directed to an abstract idea without significantly more.
Step 1 Analysis: Claim 10 is directed to a system, which is directed to a machine, one of the statutory categories.
Step 2A Prong One Analysis: The limitation:
“perform an automated alignment of model elements in UML diagrams of the UML model”
As drafted, under their broadest reasonable interpretations, cover mental processes (concepts performed in the human mind (including an observation, evaluation, judgement, opinion)) but for the recitation of mere instructions to apply language (See MPEP 2106.05(f)). The above limitations in the context of this claim encompass performing an automated alignment of model elements in UML diagrams of the UML model (corresponds to evaluation and judgement; in particular, a human, with the assistance of pen and paper, can perform an automated alignment of model elements in the UML diagrams).
Step 2A Prong Two Analysis: The judicial exceptions are not integrated into a practical application. In particular, the claim recites additional elements that are mere instructions to apply (See MPEP 2106.05(f)). The limitation:
“the set of processors”
As drafted, is an additional element that amounts to no more than mere instructions to apply the exception for the abstract ideas. See MPEP 2106.05(f). In addition, the recitation of additional elements in claim 9 of a generic communication fabric, computer-readable storage media, and processors, as drafted, are reciting mere instructions to apply language such that it amounts to no more than mere instructions to apply the exceptions. Therefore, the additional elements do not integrate the abstract ideas into a practical application.
Step 2B Analysis: The claim does not include additional elements that are sufficient to amount to significantly more than the judicial exception. As discussed above with respect to integration of the abstract idea into a practical application, all of the additional elements are “mere instructions to apply an exception” (I.e. the additional elements describe a generic communication fabric, computer-readable storage media, and processors for applying the abstract ideas). Mere instructions to apply an exception cannot provide an inventive concept. The claim is not patent eligible.
Regarding Claim 11,
Claim 11 is rejected under 35 U.S.C. 101 because the claimed invention is directed to an abstract idea without significantly more.
Step 1 Analysis: Claim 11 is directed to a system, which is directed to a machine, one of the statutory categories.
Step 2A Prong One Analysis: The limitations:
“validate the UML model corresponding to the architecture solution based on a set of standard UML model validation rules and a set of UML model validation rules specific to the architecture solution”
“rank the UML model corresponding to the architecture solution based on a set of principles and standards defined for the architecture solution”
As drafted, under their broadest reasonable interpretations, cover mental processes (concepts performed in the human mind (including an observation, evaluation, judgement, opinion)) but for the recitation of mere instructions to apply language (See MPEP 2106.05(f)). The above limitations in the context of this claim encompass validating the UML model corresponding to the architecture solution based on a set of standard UML model validation rules and a set of UML model validation rules specific to the architecture solution (corresponds to evaluation and judgement; in particular, a human, with the assistance of pen and paper, can use a set of standard UML model validation rules and a set of UML model validation rules specific to the architecture solution to validate the UML model corresponding to the architecture solution); and ranking the UML model corresponding to the architecture solution based on a set of principles and standards defined for the architecture solution (corresponds to evaluation and judgement; in particular, a human, with the assistance of pen and paper, can, based on a set of principles and standards defined for the architecture solution, ranking the UML model corresponding to the architecture solution).
Step 2A Prong Two Analysis: The judicial exceptions are not integrated into a practical application. In particular, the claim recites additional elements that are mere instructions to apply (See MPEP 2106.05(f)). The limitation:
“the set of processors”
As drafted, is an additional element that amounts to no more than mere instructions to apply the exception for the abstract ideas. See MPEP 2106.05(f). In addition, the recitation of additional elements in claim 9 of a generic communication fabric, computer-readable storage media, and processors, as drafted, are reciting mere instructions to apply language such that it amounts to no more than mere instructions to apply the exceptions. Therefore, the additional elements do not integrate the abstract ideas into a practical application.
Step 2B Analysis: The claim does not include additional elements that are sufficient to amount to significantly more than the judicial exception. As discussed above with respect to integration of the abstract idea into a practical application, all of the additional elements are “mere instructions to apply an exception” (I.e. the additional elements describe a generic communication fabric, computer-readable storage media, and processors for applying the abstract ideas). Mere instructions to apply an exception cannot provide an inventive concept. The claim is not patent eligible.
Regarding Claim 12,
Claim 12 is rejected under 35 U.S.C. 101 because the claimed invention is directed to an abstract idea without significantly more.
Step 1 Analysis: Claim 12 is directed to a system, which is directed to a machine, one of the statutory categories.
Step 2A Prong One Analysis: The limitation:
“generate an XMI representation compatibility report, a UML model validation report, and a UML model rank report for the UML model corresponding to the architecture solution”
As drafted, under their broadest reasonable interpretations, cover mental processes (concepts performed in the human mind (including an observation, evaluation, judgement, opinion)) but for the recitation of mere instructions to apply language (See MPEP 2106.05(f)). The above limitations in the context of this claim encompass generating an XMI representation compatibility report, a UML model validation report, and a UML model rank report for the UML model corresponding to the architecture solution (corresponds to evaluation and judgement; in particular, a human, with the assistance of pen and paper, can, for the UML model corresponding to the architectural solution, generate an XMI representation compatibility report, a UML model validation report, and a UML model rank report).
Step 2A Prong Two Analysis: The judicial exceptions are not integrated into a practical application. In particular, the claim recites additional elements that are mere instructions to apply (See MPEP 2106.05(f)). The limitations:
“the set of processors”
“input the XMI representation compatibility report, the UML model validation report, and the UML model rank report into a foundation model to retrain the foundation model via self-learning to increase accuracy of generating XMI representations of UML models”
As drafted, are additional elements that amount to no more than mere instructions to apply the exception for the abstract ideas. See MPEP 2106.05(f). In addition, the recitation of additional elements in claim 9 of a generic communication fabric, computer-readable storage media, and processors, as drafted, are reciting mere instructions to apply language such that it amounts to no more than mere instructions to apply the exceptions. Therefore, the additional elements do not integrate the abstract ideas into a practical application.
Step 2B Analysis: The claim does not include additional elements that are sufficient to amount to significantly more than the judicial exception. As discussed above with respect to integration of the abstract idea into a practical application, all of the additional elements are “mere instructions to apply an exception” (I.e. the additional elements describe a generic communication fabric, computer-readable storage media, processors, and model retraining for applying the abstract ideas). Mere instructions to apply an exception cannot provide an inventive concept. The claim is not patent eligible.
Regarding Claim 13,
Claim 13 is rejected under 35 U.S.C. 101 because the claimed invention is directed to an abstract idea without significantly more.
Step 1 Analysis: Claim 13 is directed to a system, which is directed to a machine, one of the statutory categories.
Step 2A Prong One Analysis: Please see the analysis of claim 12. The limitations of claim 13 are only additional elements to the abstract ideas of claim 12.
Step 2A Prong Two Analysis: The judicial exceptions are not integrated into a practical application. In particular, the claim recites additional elements that are mere instructions to apply (See MPEP 2106.05(f)) or insignificant extra-solution activity (See MPEP 2106.05(g)). The limitations:
“the set of processors”
“implement the architecture solution in an environment corresponding to the user in response to receiving an input from the user to implement the architecture solution based on the XMI representation compatibility report, the UML model validation report, and the UML model rank report”
As drafted, are additional elements that amount to no more than mere instructions to apply the exception for the abstract ideas. See MPEP 2106.05(f). The limitation:
“send the XMI representation compatibility report, the UML model validation report, and the UML model rank report to a user via a client device”
As drafted, is an additional element that corresponds to insignificant extra-solution activity. In particular, the additional elements are merely directed towards mere data gathering. See MPEP 2106.05(g). In addition, the recitation of additional elements in claim 12 of a generic communication fabric, computer-readable storage media, processors, and model retraining, as drafted, are reciting mere instructions to apply language such that it amounts to no more than mere instructions to apply the exceptions. Therefore, the additional elements do not integrate the abstract ideas into a practical application.
Step 2B Analysis: The claim does not include additional elements that are sufficient to amount to significantly more than the judicial exception. As discussed above with respect to integration of the abstract idea into a practical application, all of the additional elements are “mere instructions to apply an exception” (I.e. the additional elements describe a generic communication fabric, computer-readable storage media, processors, and model retraining for applying the abstract ideas) or insignificant extra-solution activity (i.e. sending/transmitting data). Furthermore, the “send …” limitation is insignificant extra-solution activity that is well-understood, routine, and conventional according to MPEP 2106.05(d) (“The courts have recognized the following computer functions as well‐understood, routine, and conventional functions when they are claimed in a merely generic manner (e.g., at a high level of generality) or as insignificant extra-solution activity… i. Receiving or transmitting data over a network). Mere instructions to apply an exception cannot provide an inventive concept. The claim is not patent eligible.
Regarding Claim 14,
Claim 14 is rejected under 35 U.S.C. 101 because the claimed invention is directed to an abstract idea without significantly more.
Step 1 Analysis: Claim 14 is directed to a computer program product comprising a set of computer-readable storage media, which is directed to an article of manufacture, one of the statutory categories.
Step 2A Prong One Analysis: The limitations:
“generate an Extensible Markup Language Metadata Interchange (XMI) representation of a Unified Modeling Language (UML) model corresponding to an architecture solution based on a set of instructions in a predefined format; and
generate the UML model corresponding to the architecture solution based on the XMI representation of the UML model”
As drafted, under their broadest reasonable interpretations, cover mental processes (concepts performed in the human mind (including an observation, evaluation, judgement, opinion)) but for the recitation of mere instructions to apply language (See MPEP 2106.05(f)). The above limitations in the context of this claim encompass generating an XMI representation of a UML model corresponding to an architecture solution based on a set of instructions in a predefined format (corresponds to evaluation and judgement; in particular, a human, with the assistance of pen and paper, can generate an XMI representation of a UML model corresponding to an architecture solution based on a set of instructions in a predefined format); and generating the UML model corresponding to the architecture solution based on the XMI representation of the UML model (corresponds to evaluation and judgement; in particular, a human, with the assistance of pen and paper, can, based on the XMI representation of the UML model, generate the UML corresponding to the architecture solution).
Step 2A Prong Two Analysis: The judicial exceptions are not integrated into a practical application. In particular, the claim recites additional elements that are mere instructions to apply (See MPEP 2106.05(f)). The limitations:
“a set of computer-readable storage media having program instructions collectively stored therein”
“the program instructions executable by a computer”
As drafted, are additional elements that amount to no more than mere instructions to apply the exception for the abstract ideas. See MPEP 2106.05(f). Therefore, the additional elements do not integrate the abstract ideas into a practical application.
Step 2B Analysis: The claim does not include additional elements that are sufficient to amount to significantly more than the judicial exception. As discussed above with respect to integration of the abstract idea into a practical application, all of the additional elements are “mere instructions to apply an exception” (I.e. the additional elements describe generic computer-readable storage media and computer for applying the abstract ideas). Mere instructions to apply an exception cannot provide an inventive concept. The claim is not patent eligible.
Regarding Claim 15,
Claim 15 is rejected under 35 U.S.C. 101 because the claimed invention is directed to an abstract idea without significantly more.
Step 1 Analysis: Claim 15 is directed to a computer program product comprising a set of computer-readable storage media, which is directed to an article of manufacture, one of the statutory categories.
Step 2A Prong One Analysis: The limitation:
“perform an automated alignment of model elements in UML diagrams of the UML model”
As drafted, under their broadest reasonable interpretations, cover mental processes (concepts performed in the human mind (including an observation, evaluation, judgement, opinion)) but for the recitation of mere instructions to apply language (See MPEP 2106.05(f)). The above limitations in the context of this claim encompass performing an automated alignment of model elements in UML diagrams of the UML model (corresponds to evaluation and judgement; in particular, a human, with the assistance of pen and paper, can perform an automated alignment of model elements in the UML diagrams).
Step 2A Prong Two Analysis: The judicial exceptions are not integrated into a practical application. In particular, the claim recites additional elements that are mere instructions to apply (See MPEP 2106.05(f)). The limitation:
“the computer”
As drafted, is an additional element that amounts to no more than mere instructions to apply the exception for the abstract ideas. See MPEP 2106.05(f). In addition, the recitation of additional elements in claim 14 of generic computer-readable storage media and computer, as drafted, are reciting mere instructions to apply language such that it amounts to no more than mere instructions to apply the exceptions. Therefore, the additional elements do not integrate the abstract ideas into a practical application.
Step 2B Analysis: The claim does not include additional elements that are sufficient to amount to significantly more than the judicial exception. As discussed above with respect to integration of the abstract idea into a practical application, all of the additional elements are “mere instructions to apply an exception” (I.e. the additional elements describe generic computer-readable storage media and computer for applying the abstract ideas). Mere instructions to apply an exception cannot provide an inventive concept. The claim is not patent eligible.
Regarding Claim 16,
Claim 16 is rejected under 35 U.S.C. 101 because the claimed invention is directed to an abstract idea without significantly more.
Step 1 Analysis: Claim 16 is directed to a computer program product comprising a set of computer-readable storage media, which is directed to an article of manufacture, one of the statutory categories.
Step 2A Prong One Analysis: The limitations:
“validate the UML model corresponding to the architecture solution based on a set of standard UML model validation rules and a set of UML model validation rules specific to the architecture solution”
“rank the UML model corresponding to the architecture solution based on a set of principles and standards defined for the architecture solution”
As drafted, under their broadest reasonable interpretations, cover mental processes (concepts performed in the human mind (including an observation, evaluation, judgement, opinion)) but for the recitation of mere instructions to apply language (See MPEP 2106.05(f)). The above limitations in the context of this claim encompass validating the UML model corresponding to the architecture solution based on a set of standard UML model validation rules and a set of UML model validation rules specific to the architecture solution (corresponds to evaluation and judgement; in particular, a human, with the assistance of pen and paper, can use a set of standard UML model validation rules and a set of UML model validation rules specific to the architecture solution to validate the UML model corresponding to the architecture solution); and ranking the UML model corresponding to the architecture solution based on a set of principles and standards defined for the architecture solution (corresponds to evaluation and judgement; in particular, a human, with the assistance of pen and paper, can, based on a set of principles and standards defined for the architecture solution, ranking the UML model corresponding to the architecture solution).
Step 2A Prong Two Analysis: The judicial exceptions are not integrated into a practical application. In particular, the claim recites additional elements that are mere instructions to apply (See MPEP 2106.05(f)). The limitation:
“the computer”
As drafted, is an additional element that amounts to no more than mere instructions to apply the exception for the abstract ideas. See MPEP 2106.05(f). In addition, the recitation of additional elements in claim 14 of generic computer-readable storage media and computer, as drafted, are reciting mere instructions to apply language such that it amounts to no more than mere instructions to apply the exceptions. Therefore, the additional elements do not integrate the abstract ideas into a practical application.
Step 2B Analysis: The claim does not include additional elements that are sufficient to amount to significantly more than the judicial exception. As discussed above with respect to integration of the abstract idea into a practical application, all of the additional elements are “mere instructions to apply an exception” (I.e. the additional elements describe generic computer-readable storage media and computer for applying the abstract ideas). Mere instructions to apply an exception cannot provide an inventive concept. The claim is not patent eligible.
Regarding Claim 17,
Claim 17 is rejected under 35 U.S.C. 101 because the claimed invention is directed to an abstract idea without significantly more.
Step 1 Analysis: Claim 17 is directed to a computer program product comprising a set of computer-readable storage media, which is directed to an article of manufacture, one of the statutory categories.
Step 2A Prong One Analysis: The limitation:
“generate an XMI representation compatibility report, a UML model validation report, and a UML model rank report for the UML model corresponding to the architecture solution”
As drafted, under their broadest reasonable interpretations, cover mental processes (concepts performed in the human mind (including an observation, evaluation, judgement, opinion)) but for the recitation of mere instructions to apply language (See MPEP 2106.05(f)). The above limitations in the context of this claim encompass generating an XMI representation compatibility report, a UML model validation report, and a UML model rank report for the UML model corresponding to the architecture solution (corresponds to evaluation and judgement; in particular, a human, with the assistance of pen and paper, can, for the UML model corresponding to the architectural solution, generate an XMI representation compatibility report, a UML model validation report, and a UML model rank report).
Step 2A Prong Two Analysis: The judicial exceptions are not integrated into a practical application. In particular, the claim recites additional elements that are mere instructions to apply (See MPEP 2106.05(f)). The limitations:
“the computer”
“input the XMI representation compatibility report, the UML model validation report, and the UML model rank report into a foundation model to retrain the foundation model via self-learning to increase accuracy of generating XMI representations of UML models”
As drafted, are additional elements that amount to no more than mere instructions to apply the exception for the abstract ideas. See MPEP 2106.05(f). In addition, the recitation of additional elements in claim 14 of generic computer-readable storage media and computer, as drafted, are reciting mere instructions to apply language such that it amounts to no more than mere instructions to apply the exceptions. Therefore, the additional elements do not integrate the abstract ideas into a practical application.
Step 2B Analysis: The claim does not include additional elements that are sufficient to amount to significantly more than the judicial exception. As discussed above with respect to integration of the abstract idea into a practical application, all of the additional elements are “mere instructions to apply an exception” (I.e. the additional elements describe generic computer-readable storage media, computer, and model retraining for applying the abstract ideas). Mere instructions to apply an exception cannot provide an inventive concept. The claim is not patent eligible.
Regarding Claim 18,
Claim 18 is rejected under 35 U.S.C. 101 because the claimed invention is directed to an abstract idea without significantly more.
Step 1 Analysis: Claim 18 is directed to a computer program product comprising a set of computer-readable storage media, which is directed to an article of manufacture, one of the statutory categories.
Step 2A Prong One Analysis: Please see the analysis of claim 17. The limitations of claim 18 are only additional elements to the abstract ideas of claim 17.
Step 2A Prong Two Analysis: The judicial exceptions are not integrated into a practical application. In particular, the claim recites additional elements that are mere instructions to apply (See MPEP 2106.05(f)) or insignificant extra-solution activity (See MPEP 2106.05(g)). The limitations:
“the computer”
“implement the architecture solution in an environment corresponding to the user in response to receiving an input from the user to implement the architecture solution based on the XMI representation compatibility report, the UML model validation report, and the UML model rank report”
As drafted, are additional elements that amount to no more than mere instructions to apply the exception for the abstract ideas. See MPEP 2106.05(f). The limitation:
“send the XMI representation compatibility report, the UML model validation report, and the UML model rank report to a user via a client device”
As drafted, is an additional element that corresponds to insignificant extra-solution activity. In particular, the additional elements are merely directed towards mere data gathering. See MPEP 2106.05(g). In addition, the recitation of additional elements in claim 17 of a generic computer-readable storage media, computer, and model retraining, as drafted, are reciting mere instructions to apply language such that it amounts to no more than mere instructions to apply the exceptions. Therefore, the additional elements do not integrate the abstract ideas into a practical application.
Step 2B Analysis: The claim does not include additional elements that are sufficient to amount to significantly more than the judicial exception. As discussed above with respect to integration of the abstract idea into a practical application, all of the additional elements are “mere instructions to apply an exception” (I.e. the additional elements describe a generic computer-readable storage media, computer, and model retraining for applying the abstract ideas) or insignificant extra-solution activity (i.e. sending/transmitting data). Furthermore, the “send …” limitation is insignificant extra-solution activity that is well-understood, routine, and conventional according to MPEP 2106.05(d) (“The courts have recognized the following computer functions as well‐understood, routine, and conventional functions when they are claimed in a merely generic manner (e.g., at a high level of generality) or as insignificant extra-solution activity… i. Receiving or transmitting data over a network). Mere instructions to apply an exception cannot provide an inventive concept. The claim is not patent eligible.
Regarding Claim 19,
Claim 19 is rejected under 35 U.S.C. 101 because the claimed invention is directed to an abstract idea without significantly more.
Step 1 Analysis: Claim 19 is directed to a computer program product comprising a set of computer-readable storage media, which is directed to an article of manufacture, one of the statutory categories.
Step 2A Prong One Analysis: The limitation:
“verify compatibility of the XMI representation of the UML model corresponding to the architecture solution with the architecture modeling tool”
As drafted, under their broadest reasonable interpretations, cover mental processes (concepts performed in the human mind (including an observation, evaluation, judgement, opinion)) but for the recitation of mere instructions to apply language (See MPEP 2106.05(f)) and insignificant extra-solution activity (See MPEP 2106.05(g)). The above limitations in the context of this claim encompass verifying compatibility of the XMI representation of the UML model corresponding to the architecture solution with the architecture modeling tool (corresponds to evaluation and judgement; in particular, a human, with the assistance of pen and paper, can verify compatibility of the XMI representation of the UML model corresponding to the architecture solution with the architecture modeling tool).
Step 2A Prong Two Analysis: The judicial exceptions are not integrated into a practical application. In particular, the claim recites additional elements that are mere instructions to apply (See MPEP 2106.05(f)) or insignificant extra-solution activity (See MPEP 2106.05(g)). The limitation:
“the computer”
As drafted, are additional elements that amount to no more than mere instructions to apply the exception for the abstract ideas. See MPEP 2106.05(f). The limitation:
“import the XMI representation of the UML model corresponding to the architecture solution into an architecture modeling tool”
As drafted, is an additional element that corresponds to insignificant extra-solution activity. In particular, the additional elements are merely directed towards mere data gathering. See MPEP 2106.05(g). In addition, the recitation of additional elements in claim 14 of generic computer-readable storage media and computer, as drafted, are reciting mere instructions to apply language such that it amounts to no more than mere instructions to apply the exceptions. Therefore, the additional elements do not integrate the abstract ideas into a practical application.
Step 2B Analysis: The claim does not include additional elements that are sufficient to amount to significantly more than the judicial exception. As discussed above with respect to integration of the abstract idea into a practical application, all of the additional elements are “mere instructions to apply an exception” (I.e. the additional elements describe generic computer-readable storage media and computer for applying the abstract ideas) or insignificant extra-solution activity (i.e. importing/transmitting data). Furthermore, the “importing …” limitation is insignificant extra-solution activity that is well-understood, routine, and conventional according to MPEP 2106.05(d) (“The courts have recognized the following computer functions as well‐understood, routine, and conventional functions when they are claimed in a merely generic manner (e.g., at a high level of generality) or as insignificant extra-solution activity… i. Receiving or transmitting data over a network). Mere instructions to apply an exception cannot provide an inventive concept. The claim is not patent eligible.
Regarding Claim 20,
Claim 20 is rejected under 35 U.S.C. 101 because the claimed invention is directed to an abstract idea without significantly more.
Step 1 Analysis: Claim 20 is directed to a computer program product comprising a set of computer-readable storage media, which is directed to an article of manufacture, one of the statutory categories.
Step 2A Prong One Analysis: The limitations:
“perform an analysis of the set of project-specific architecture solution needs corresponding to the architecture solution received from the user via the client device”
“convert, …, the set of project-specific architecture solution needs corresponding to the architecture solution into the set of instructions in the predefined format based on the analysis of the set of project-specific architecture solution needs”
As drafted, under their broadest reasonable interpretations, cover mental processes (concepts performed in the human mind (including an observation, evaluation, judgement, opinion)) but for the recitation of mere instructions to apply language (See MPEP 2106.05(f)) and insignificant extra-solution activity (See MPEP 2106.05(g)). The above limitations in the context of this claim encompass performing an analysis of the set of project-specific architecture solution needs corresponding to the architecture solution received from the user via the client device (corresponds to evaluation and judgement; in particular, a human, with the assistance of pen and paper, can perform an analysis of the set of project-specific architecture solution needs corresponding to the architecture solution); and converting the set of project-specific architecture solution needs corresponding to the architecture solution into the set of instructions in the predefined format based on the analysis of the set of project-specific architecture solution needs (corresponds to evaluation and judgement; in particular, a human, with the assistance of pen and paper, can, based on the analysis of the set of project-specific architecture solution needs, convert the set of project-specific architecture solution needs corresponding to the architecture solution into the set of instructions in the predefined format).
Step 2A Prong Two Analysis: The judicial exceptions are not integrated into a practical application. In particular, the claim recites additional elements that are mere instructions to apply (See MPEP 2106.05(f)) or insignificant extra-solution activity (See MPEP 2106.05(g)). The limitations:
“the computer”
“a client device”
“using a foundation model”
As drafted, are additional elements that amount to no more than mere instructions to apply the exception for the abstract ideas. See MPEP 2106.05(f). The limitation:
“receive a set of project-specific architecture solution needs corresponding to the architecture solution from a user via a client device”
As drafted, is an additional element that corresponds to insignificant extra-solution activity. In particular, the additional elements are merely directed towards mere data gathering. See MPEP 2106.05(g). In addition, the recitation of additional elements in claim 14 of generic computer-readable storage media and computer, as drafted, are reciting mere instructions to apply language such that it amounts to no more than mere instructions to apply the exceptions. Therefore, the additional elements do not integrate the abstract ideas into a practical application.
Step 2B Analysis: The claim does not include additional elements that are sufficient to amount to significantly more than the judicial exception. As discussed above with respect to integration of the abstract idea into a practical application, all of the additional elements are “mere instructions to apply an exception” (I.e. the additional elements describe generic computer-readable storage media, computer, client device, and model for applying the abstract ideas) or insignificant extra-solution activity (i.e. receiving data). Furthermore, the “receive …” limitation is insignificant extra-solution activity that is well-understood, routine, and conventional according to MPEP 2106.05(d) (“The courts have recognized the following computer functions as well‐understood, routine, and conventional functions when they are claimed in a merely generic manner (e.g., at a high level of generality) or as insignificant extra-solution activity… i. Receiving or transmitting data over a network). Mere instructions to apply an exception cannot provide an inventive concept. The claim is not patent eligible.
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.
The factual inquiries for establishing a background for determining obviousness under 35 U.S.C. 103 are summarized as follows:
1. Determining the scope and contents of the prior art.
2. Ascertaining the differences between the prior art and the claims at issue.
3. Resolving the level of ordinary skill in the pertinent art.
4. Considering objective evidence present in the application indicating obviousness or nonobviousness.
This application currently names joint inventors. In considering patentability of the claims the examiner presumes that the subject matter of the various claims was commonly owned as of the effective filing date of the claimed invention(s) absent any evidence to the contrary. Applicant is advised of the obligation under 37 CFR 1.56 to point out the inventor and effective filing dates of each claim that was not commonly owned as of the effective filing date of the later invention in order for the examiner to consider the applicability of 35 U.S.C. 102(b)(2)(C) for any potential 35 U.S.C. 102(a)(2) prior art against the later invention.
Claims 1-2, 6-10, 14-15, and 19-20 are rejected under 35 U.S.C. 103 as being unpatentable over Brunel et al. (US 2007/0277151 A1) in view of Deeptimahanti et al. ("Semi-automatic generation of UML models from natural language requirements").
Regarding Claim 1,
Brunel et al. teaches a computer-implemented method for generating architecture solutions ([0003]: "The present invention relates generally to graphical programming or modeling environments for modeling programs and more particularly to methods, mediums and systems for providing a graphical action language for a model in Unified Modeling Language (UML) or its dialects or extensions" teaches a method for providing a graphical action language for a model (e.g. generating architecture solutions) in Unified Modeling Language (UML). [0021]: "a medium is provided for use with a computing device holding instructions executable by the computing device for performing a method" teaches that the method is implemented using a computing device (computer)), the computer-implemented method comprising:
generating, by a computer, an Extensible Markup Language Metadata Interchange (XMI) representation of a Unified Modeling Language (UML) model corresponding to an architecture solution based on a set of instructions in a predefined format ([0043]: "a UML model may be exported into a text-based format, such as an XML Metadata Interface (XMI) format. The modeling environment may read the XMI format and publish the components of the UML model using hierarchical computational blocks provided in the modeling environment" teaches generating an XMI representation of a UML model. [0051]: "the graphical programming or modeling environment may generate a sequence diagram automatically from the interpreted, compiled, or mixed execution of the model. The sequence diagram is one of the UML interaction models. The generated sequence diagram may be converted into a text-based format, such as the XML format, and merged into the text-based XMI format of the UML component model so that the UML source model contains the component diagram and the sequence diagram" teaches the XMI of the UML model corresponding to the model sequence diagram (architecture solution) based on a text-based format (predefined format). Fig. 1; [0068]: "The abstract model 5 can be exported into a text-based data format 6. The text-based data format 6 may contain information on the graphical and non-graphical aspects of the model 5. The text-based data format 6 may be described using the XML Metadata Interface (XMI) format" teaches that the XMI representation of the abstract (UML) model is based on information on the graphical and non-graphical aspects of the model in a text-based data format (instructions in a predefined format)).
Brunel et al. does not appear to explicitly teach generating, by the computer, the UML model corresponding to the architecture solution based on the XMI representation of the UML model.
However, Deeptimahanti et al. teaches generating, by the computer, the UML model corresponding to the architecture solution based on the XMI representation of the UML model (Section 2.4, first paragraph: "To address existing limitations, UMGAR makes following contributions aimed to support automatic generation of possible UML models from SRS written in natural language without need of extensive domain expertise and user interaction: ... It provides a XMI parser to generate XMI file and can be visualized in any UML modeling tool which has XMI import feature" teaches that the generated XMI file (XMI representation) corresponding to the software requirement specifications (architecture solution) is used to generate the UML model. Section 4.5, first paragraph: "UMGAR provides an efficient XMI parser to support the visualization and manipulation of the generated models in any modeling tool, which has XMI import feature. The XMI file [12] generated by UMGAR’s parser follows XMI v2.1 specifications. This parser is currently supporting all models generated by UMGAR. Models can be modified after imported into modeling tool. We have successfully tested this XMI parser over Argo-UML [36] and Enterprise Architect [35] UML modeling tools" teaches generating the UML model based on the XMI file (XMI representation) corresponding to the UML model).
Brunel et al. and Deeptimahanti et al. are analogous to the claimed invention because they are directed towards the implementation of XMI representations of UML models.
It would have been obvious to one of ordinary skill in the art before the effective filing date of the claimed invention to incorporate generating, by the computer, the UML model corresponding to the architecture solution based on the XMI representation of the UML model as taught by Deeptimahanti et al. to the disclosed invention of Brunel et al.
One of ordinary skill in the art would have been motivated to make this modification because "UMGAR has several advantages … [including] addressing the problems caused by lack of domain knowledge by using efficient NLP tools … [and to be] able to visualize UML diagrams in any UML modeling tool that has XMI import feature" (Deeptimahanti et al. Section 5, first paragraph).
Regarding Claim 2,
Brunel et al. in view of Deeptimahanti et al. teaches the computer-implemented method of claim 1.
In addition, Brunel et al. further teaches further comprising: performing, by the computer, an automated alignment of model elements in UML diagrams of the UML model ([0045]: "The graphical programming or modeling environment enables graphical modeling of the behavior of the UML model so that the model can be executed in the graphical programming or modeling environment. Execution may be realized by running of code that results from code generation or by interpreting the model. Different versions of code can be automatically generated from the graphical action language and deployment artifacts of the corresponding elements of the UML model. A deployment artifact is a combination of requirements and instructions for compiling and/or executing the UML model" teaches that the graphical programming or modeling environment (e.g. implemented by the computer) automatically generates code from deployment artifacts of the corresponding elements of the UML model (model elements in UML diagrams of the UML model). [0051]: "the graphical programming or modeling environment may generate a sequence diagram automatically from the interpreted, compiled, or mixed execution of the model. The sequence diagram is one of the UML interaction models" teaches that the graphical programming or modeling environment (e.g. implemented by the computer) automatically generates a sequence diagram (e.g. automatically aligns) UML diagrams of the UML model. Fig. 1; [0083]: "The graphical programming or modeling environment 8 receives the UML model and binds its elements to the specification of the UML model or the components of the UML model to represent the UML model or the components of the UML model in the graphical programming or modeling environment 8" teaches that the graphical programming or modeling environment (e.g. implemented by the computer) binds/aligns elements (model elements in UML diagrams) of the UML model).
Regarding Claim 6,
Brunel et al. in view of Deeptimahanti et al. teaches the computer-implemented method of claim 1.
In addition, Deeptimahanti et al. further teaches further comprising: importing, by the computer, the XMI representation of the UML model corresponding to the architecture solution into an architecture modeling tool (Section 2.4, first paragraph: "To address existing limitations, UMGAR makes following contributions aimed to support automatic generation of possible UML models from SRS written in natural language without need of extensive domain expertise and user interaction: ... It provides a XMI parser to generate XMI file and can be visualized in any UML modeling tool which has XMI import feature" teaches that the generated XMI file (XMI representation) of the UML model is imported into a UML modeling tool (architecture modeling tool)); and
verifying, by the computer, compatibility of the XMI representation of the UML model corresponding to the architecture solution with the architecture modeling tool (Section 4.5, first paragraph: "UMGAR provides an efficient XMI parser to support the visualization and manipulation of the generated models in any modeling tool, which has XMI import feature. The XMI file [12] generated by UMGAR’s parser follows XMI v2.1 specifications. This parser is currently supporting all models generated by UMGAR. Models can be modified after imported into modeling tool. We have successfully tested this XMI parser over Argo-UML [36] and Enterprise Architect [35] UML modeling tools" teaches generating the UML model based on the XMI file (XMI representation) corresponding to the UML model, the XMI file (XMI representation) being imported into a UML modeling tool (architecture modeling tool). Section 5, first paragraph: "We have presented and discussed various features of UMGAR by using “Qualification Verification System (QVS)” case system. Our results are quite encouraging in terms of automatic identification of OO elements found from the case systems by UMGAR. UMGAR is also able to visualize UML diagrams in any UML modeling tool that has XMI import feature" teaches that UMGAR uses a verification system for the generated XMI file (XMI representation) of the UML model that is imported into a UML modeling tool (architecture modeling tool)).
Brunel et al. and Deeptimahanti et al. are analogous to the claimed invention because they are directed towards the implementation of XMI representations of UML models.
It would have been obvious to one of ordinary skill in the art before the effective filing date of the claimed invention to incorporate further comprising: importing, by the computer, the XMI representation of the UML model corresponding to the architecture solution into an architecture modeling tool; and verifying, by the computer, compatibility of the XMI representation of the UML model corresponding to the architecture solution with the architecture modeling tool as taught by Deeptimahanti et al. to the disclosed invention of Brunel et al.
One of ordinary skill in the art would have been motivated to make this modification because "UMGAR has several advantages … [including] addressing the problems caused by lack of domain knowledge by using efficient NLP tools … [and to be] able to visualize UML diagrams in any UML modeling tool that has XMI import feature" (Deeptimahanti et al. Section 5, first paragraph).
Regarding Claim 7,
Brunel et al. in view of Deeptimahanti et al. teaches the computer-implemented method of claim 1.
In addition, Brunel et al. further teaches further comprising: receiving, by the computer, a set of project-specific architecture solution needs corresponding to the architecture solution from a user via a client device ([0044]-[0045]: "The graphical programming or modeling environment enables a user to edit a UML model. Editing the UML model may include adding new modeling elements such as interaction models that show an exchange of messages between run-time objects. In another embodiment of the invention, editing the UML model may involve adding tag-value pairs to one or more UML modeling elements to hold extra information such as information resulting from the graphical modeling and execution activities. In yet another embodiment of the invention, editing the UML model may involve modifying existing model elements, such as existing tagged values, and datatypes of operation ... The graphical programming or modeling environment enables graphical modeling of the behavior of the UML model so that the model can be executed in the graphical programming or modeling environment. Execution may be realized by running of code that results from code generation or by interpreting the model. Different versions of code can be automatically generated from the graphical action language and deployment artifacts of the corresponding elements of the UML model. A deployment artifact is a combination of requirements and instructions for compiling and/or executing the UML model" teaches that the graphical programming or modeling environment (e.g. implemented by the computer) receives user input for modelling the UML model including deployment artifacts (project-specific architecture solution needs) that comprise a combination of requirements and instructions for compiling and/or executing the UML model);
performing, by the computer, an analysis of the set of project-specific architecture solution needs corresponding to the architecture solution received from the user via the client device ([0044]-[0045]: "The graphical programming or modeling environment enables a user to edit a UML model. Editing the UML model may include adding new modeling elements such as interaction models that show an exchange of messages between run-time objects. In another embodiment of the invention, editing the UML model may involve adding tag-value pairs to one or more UML modeling elements to hold extra information such as information resulting from the graphical modeling and execution activities. In yet another embodiment of the invention, editing the UML model may involve modifying existing model elements, such as existing tagged values, and datatypes of operation ... The graphical programming or modeling environment enables graphical modeling of the behavior of the UML model so that the model can be executed in the graphical programming or modeling environment. Execution may be realized by running of code that results from code generation or by interpreting the model. Different versions of code can be automatically generated from the graphical action language and deployment artifacts of the corresponding elements of the UML model. A deployment artifact is a combination of requirements and instructions for compiling and/or executing the UML model" teaches that the graphical programming or modeling environment (e.g. implemented by the computer) receives user input for modelling the UML model including deployment artifacts (project-specific architecture solution needs) that comprise a combination of requirements and instructions for compiling and/or executing the UML model. [0020]: "the action language is used for coverage analysis to identify which elements of a model have been evaluated during a set of executions. In yet another aspect, the action language is used to analyze the time it takes for model elements to be evaluated. This timing analysis can be used to schedule the execution of model elements so as to achieve real-time behavior on a given computing platform. In a further aspect, the action language is used to automatically generate tests that contain input values to the model. The generated tests are generated so as to invoke certain behavior of the model or so as to enforce evaluation of certain model elements" teaches that the action language and deployment artifacts (project-specific architecture solution needs) is used for performing an analysis corresponding to the model (architecture solution)); and
converting, by the computer, using a foundation model, the set of project-specific architecture solution needs corresponding to the architecture solution into the set of instructions in the predefined format based on the analysis of the set of project-specific architecture solution needs ([0044]-[0045]: "The graphical programming or modeling environment enables a user to edit a UML model. Editing the UML model may include adding new modeling elements such as interaction models that show an exchange of messages between run-time objects. In another embodiment of the invention, editing the UML model may involve adding tag-value pairs to one or more UML modeling elements to hold extra information such as information resulting from the graphical modeling and execution activities. In yet another embodiment of the invention, editing the UML model may involve modifying existing model elements, such as existing tagged values, and datatypes of operation ... The graphical programming or modeling environment enables graphical modeling of the behavior of the UML model so that the model can be executed in the graphical programming or modeling environment. Execution may be realized by running of code that results from code generation or by interpreting the model. Different versions of code can be automatically generated from the graphical action language and deployment artifacts of the corresponding elements of the UML model. A deployment artifact is a combination of requirements and instructions for compiling and/or executing the UML model" teaches that the graphical programming or modeling environment (e.g. implemented by the computer) receives user input for modelling the UML model including deployment artifacts (project-specific architecture solution needs) that comprise a combination of requirements and instructions for compiling and/or executing the UML model. [0051]: "the graphical programming or modeling environment may generate a sequence diagram automatically from the interpreted, compiled, or mixed execution of the model. The sequence diagram is one of the UML interaction models. The generated sequence diagram may be converted into a text-based format, such as the XML format, and merged into the text-based XMI format of the UML component model so that the UML source model contains the component diagram and the sequence diagram" teaches the XMI of the UML model corresponding to the model sequence diagram (architecture solution) based on a text-based format (predefined format). Fig. 1; [0068]: "The abstract model 5 can be exported into a text-based data format 6. The text-based data format 6 may contain information on the graphical and non-graphical aspects of the model 5. The text-based data format 6 may be described using the XML Metadata Interface (XMI) format" teaches that the XMI representation of the abstract (UML) model is based on information on the graphical and non-graphical aspects of the model (project-specific architecture solution needs) in a text-based data format (instructions in a predefined format)).
Regarding Claim 8,
Brunel et al. in view of Deeptimahanti et al. teaches the computer-implemented method of claim 7.
In addition, Brunel et al. further teaches wherein the set of project-specific architecture solution needs corresponding to the architecture solution includes at least one of a system context diagram, an architecture overview diagram, a component diagram, a deployment diagram, a set of functional requirements, and a set on non-functional requirements ([0044]-[0045]: "The graphical programming or modeling environment enables a user to edit a UML model. Editing the UML model may include adding new modeling elements such as interaction models that show an exchange of messages between run-time objects. In another embodiment of the invention, editing the UML model may involve adding tag-value pairs to one or more UML modeling elements to hold extra information such as information resulting from the graphical modeling and execution activities. In yet another embodiment of the invention, editing the UML model may involve modifying existing model elements, such as existing tagged values, and datatypes of operation ... The graphical programming or modeling environment enables graphical modeling of the behavior of the UML model so that the model can be executed in the graphical programming or modeling environment. Execution may be realized by running of code that results from code generation or by interpreting the model. Different versions of code can be automatically generated from the graphical action language and deployment artifacts of the corresponding elements of the UML model. A deployment artifact is a combination of requirements and instructions for compiling and/or executing the UML model" teaches that the graphical programming or modeling environment (e.g. implemented by the computer) receives user input for modelling the UML model including deployment artifacts (project-specific architecture solution needs) that comprise a combination of requirements and instructions (e.g. functional and non-functional requirements) for compiling and/or executing the UML model).
Additionally, Deeptimahanti et al. further teaches wherein the predefined format is usable by a generative artificial intelligence-based XMI generator and an architecture model automation component of the computer (Abstract: "One main reason for such potential problems is due to the specification of software requirements in Natural Language format. To overcome some of these defects we have proposed a technique, which aims to provide semi- automated assistance for developers to generate UML models from normalized natural language requirements using Natural Language Processing techniques. This technique initially focuses on generating use-case diagram and analysis class model (conceptual model) followed by collaboration model generation for each use-case. Then it generates a consolidated design class model from which code model can also be generated. It also provides requirement traceability both at design and code levels by using Key-Word-In-Context and Concept Location techniques respectively to identify inconsistencies in requirements. Finally, this technique generates XML Metadata Interchange (XMI) files for visualizing generated models in any UML modeling tool having XMI import feature" teaches that a NLP based (AI based) XMI generator uses the natural language format (predefined format) along with a UML modeling tool (architecture model automation component)).
Brunel et al. and Deeptimahanti et al. are analogous to the claimed invention because they are directed towards the implementation of XMI representations of UML models.
It would have been obvious to one of ordinary skill in the art before the effective filing date of the claimed invention to incorporate wherein the predefined format is usable by a generative artificial intelligence-based XMI generator and an architecture model automation component of the computer as taught by Deeptimahanti et al. to the disclosed invention of Brunel et al.
One of ordinary skill in the art would have been motivated to make this modification because "UMGAR has several advantages … [including] addressing the problems caused by lack of domain knowledge by using efficient NLP tools … [and to be] able to visualize UML diagrams in any UML modeling tool that has XMI import feature" (Deeptimahanti et al. Section 5, first paragraph).
Regarding Claim 9,
Brunel et al. teaches a computer system for generating architecture solutions, the computer system comprising: a communication fabric; a set of computer-readable storage media connected to the communication fabric, wherein the set of computer-readable storage media collectively stores program instructions; and a set of processors connected to the communication fabric, wherein the set of processors executes the program instructions ([0003]: "The present invention relates generally to graphical programming or modeling environments for modeling programs and more particularly to methods, mediums and systems for providing a graphical action language for a model in Unified Modeling Language (UML) or its dialects or extensions" teaches a system for providing a graphical action language for a model (e.g. generating architecture solutions) in Unified Modeling Language (UML). Fig. 2; [0070]-[0073]: "FIG. 2 is an exemplary computing device 10 suitable for practicing the illustrative embodiment of the present invention ... The computing device 10 may be electronic and include an execution unit 11, memory 12, storage 13, an input control 14, a modem 15, a network interface 16, a display 17, etc. The execution unit 11 controls each component of the computing device 10 to provide a programming or modeling environment. The memory 12 temporarily stores instructions and data and provides them to the execution unit 11 so that the execution unit 11 operates the computing device 10 and runs the modeling or programming environment. The storage 13 usually contains software tools for applications. The storage 13 includes, in particular, code 20 for the operating system (OS) of the device 10, code 21 for applications running on the operation system including applications for providing the modeling or programming environment, and data 22 for models in the programming or modeling environment ... the computing device 10 may include multiple Central Processing Units (CPUs) for executing software loaded in the memory 12, and other programs for controlling system hardware. Each of the CPUs can be a single or multiple core processor ... The resources depicted in FIG. 2 may be connected to each other through the bus 23. The bus 23 may be an on-chip, off-chip or network bus. The bus 23 may include a control-area network (such as CAN, FlexRay, TTP, ARINC for e.g. Automotive and avionic applications) bus" teaches the system being a computing device comprising a communication bus (communication fabric), memory and storage (e.g. computer-readable storage media) connected to the bus and storing program instructions, and processors connected to the bus and configured to execute the program instructions) to:
generate an Extensible Markup Language Metadata Interchange (XMI) representation of a Unified Modeling Language (UML) model corresponding to an architecture solution based on a set of instructions in a predefined format ([0043]: "a UML model may be exported into a text-based format, such as an XML Metadata Interface (XMI) format. The modeling environment may read the XMI format and publish the components of the UML model using hierarchical computational blocks provided in the modeling environment" teaches generating an XMI representation of a UML model. [0051]: "the graphical programming or modeling environment may generate a sequence diagram automatically from the interpreted, compiled, or mixed execution of the model. The sequence diagram is one of the UML interaction models. The generated sequence diagram may be converted into a text-based format, such as the XML format, and merged into the text-based XMI format of the UML component model so that the UML source model contains the component diagram and the sequence diagram" teaches the XMI of the UML model corresponding to the model sequence diagram (architecture solution) based on a text-based format (predefined format). Fig. 1; [0068]: "The abstract model 5 can be exported into a text-based data format 6. The text-based data format 6 may contain information on the graphical and non-graphical aspects of the model 5. The text-based data format 6 may be described using the XML Metadata Interface (XMI) format" teaches that the XMI representation of the abstract (UML) model is based on information on the graphical and non-graphical aspects of the model in a text-based data format (instructions in a predefined format)).
Brunel et al. does not appear to explicitly teach generate the UML model corresponding to the architecture solution based on the XMI representation of the UML model.
However, Deeptimahanti et al. teaches generate the UML model corresponding to the architecture solution based on the XMI representation of the UML model (Section 2.4, first paragraph: "To address existing limitations, UMGAR makes following contributions aimed to support automatic generation of possible UML models from SRS written in natural language without need of extensive domain expertise and user interaction: ... It provides a XMI parser to generate XMI file and can be visualized in any UML modeling tool which has XMI import feature" teaches that the generated XMI file (XMI representation) corresponding to the software requirement specifications (architecture solution) is used to generate the UML model. Section 4.5, first paragraph: "UMGAR provides an efficient XMI parser to support the visualization and manipulation of the generated models in any modeling tool, which has XMI import feature. The XMI file [12] generated by UMGAR’s parser follows XMI v2.1 specifications. This parser is currently supporting all models generated by UMGAR. Models can be modified after imported into modeling tool. We have successfully tested this XMI parser over Argo-UML [36] and Enterprise Architect [35] UML modeling tools" teaches generating the UML model based on the XMI file (XMI representation) corresponding to the UML model).
Brunel et al. and Deeptimahanti et al. are analogous to the claimed invention because they are directed towards the implementation of XMI representations of UML models.
It would have been obvious to one of ordinary skill in the art before the effective filing date of the claimed invention to incorporate generate the UML model corresponding to the architecture solution based on the XMI representation of the UML model as taught by Deeptimahanti et al. to the disclosed invention of Brunel et al.
One of ordinary skill in the art would have been motivated to make this modification because "UMGAR has several advantages … [including] addressing the problems caused by lack of domain knowledge by using efficient NLP tools … [and to be] able to visualize UML diagrams in any UML modeling tool that has XMI import feature" (Deeptimahanti et al. Section 5, first paragraph).
Regarding Claim 10,
Brunel et al. in view of Deeptimahanti et al. teaches the computer system of claim 9.
In addition, Brunel et al. further teaches wherein the set of processors further executes the program instructions to: perform an automated alignment of model elements in UML diagrams of the UML model ([0045]: "The graphical programming or modeling environment enables graphical modeling of the behavior of the UML model so that the model can be executed in the graphical programming or modeling environment. Execution may be realized by running of code that results from code generation or by interpreting the model. Different versions of code can be automatically generated from the graphical action language and deployment artifacts of the corresponding elements of the UML model. A deployment artifact is a combination of requirements and instructions for compiling and/or executing the UML model" teaches that the graphical programming or modeling environment (e.g. implemented by the computer) automatically generates code from deployment artifacts of the corresponding elements of the UML model (model elements in UML diagrams of the UML model). [0051]: "the graphical programming or modeling environment may generate a sequence diagram automatically from the interpreted, compiled, or mixed execution of the model. The sequence diagram is one of the UML interaction models" teaches that the graphical programming or modeling environment (e.g. implemented by the computer) automatically generates a sequence diagram (e.g. automatically aligns) UML diagrams of the UML model. Fig. 1; [0083]: "The graphical programming or modeling environment 8 receives the UML model and binds its elements to the specification of the UML model or the components of the UML model to represent the UML model or the components of the UML model in the graphical programming or modeling environment 8" teaches that the graphical programming or modeling environment (e.g. implemented by the computer) binds/aligns elements (model elements in UML diagrams) of the UML model).
Regarding Claim 14,
Brunel et al. teaches a computer program product for generating architecture solutions, the computer program product comprising a set of computer-readable storage media having program instructions collectively stored therein, the program instructions executable by a computer to cause the computer ([0003]: "The present invention relates generally to graphical programming or modeling environments for modeling programs and more particularly to methods, mediums and systems for providing a graphical action language for a model in Unified Modeling Language (UML) or its dialects or extensions" teaches a medium (computer-readable storage media) for providing a graphical action language for a model (e.g. generating architecture solutions) in Unified Modeling Language (UML). [0021]: "a medium is provided for use with a computing device holding instructions executable by the computing device for performing a method" teaches that the medium is storing instructions (computer program product) for execution using a computing device (computer)) to:
generate an Extensible Markup Language Metadata Interchange (XMI) representation of a Unified Modeling Language (UML) model corresponding to an architecture solution based on a set of instructions in a predefined format ([0043]: "a UML model may be exported into a text-based format, such as an XML Metadata Interface (XMI) format. The modeling environment may read the XMI format and publish the components of the UML model using hierarchical computational blocks provided in the modeling environment" teaches generating an XMI representation of a UML model. [0051]: "the graphical programming or modeling environment may generate a sequence diagram automatically from the interpreted, compiled, or mixed execution of the model. The sequence diagram is one of the UML interaction models. The generated sequence diagram may be converted into a text-based format, such as the XML format, and merged into the text-based XMI format of the UML component model so that the UML source model contains the component diagram and the sequence diagram" teaches the XMI of the UML model corresponding to the model sequence diagram (architecture solution) based on a text-based format (predefined format). Fig. 1; [0068]: "The abstract model 5 can be exported into a text-based data format 6. The text-based data format 6 may contain information on the graphical and non-graphical aspects of the model 5. The text-based data format 6 may be described using the XML Metadata Interface (XMI) format" teaches that the XMI representation of the abstract (UML) model is based on information on the graphical and non-graphical aspects of the model in a text-based data format (instructions in a predefined format)).
Brunel et al. does not appear to explicitly teach generate the UML model corresponding to the architecture solution based on the XMI representation of the UML model.
However, Deeptimahanti et al. teaches generate the UML model corresponding to the architecture solution based on the XMI representation of the UML model (Section 2.4, first paragraph: "To address existing limitations, UMGAR makes following contributions aimed to support automatic generation of possible UML models from SRS written in natural language without need of extensive domain expertise and user interaction: ... It provides a XMI parser to generate XMI file and can be visualized in any UML modeling tool which has XMI import feature" teaches that the generated XMI file (XMI representation) corresponding to the software requirement specifications (architecture solution) is used to generate the UML model. Section 4.5, first paragraph: "UMGAR provides an efficient XMI parser to support the visualization and manipulation of the generated models in any modeling tool, which has XMI import feature. The XMI file [12] generated by UMGAR’s parser follows XMI v2.1 specifications. This parser is currently supporting all models generated by UMGAR. Models can be modified after imported into modeling tool. We have successfully tested this XMI parser over Argo-UML [36] and Enterprise Architect [35] UML modeling tools" teaches generating the UML model based on the XMI file (XMI representation) corresponding to the UML model).
Brunel et al. and Deeptimahanti et al. are analogous to the claimed invention because they are directed towards the implementation of XMI representations of UML models.
It would have been obvious to one of ordinary skill in the art before the effective filing date of the claimed invention to incorporate generate the UML model corresponding to the architecture solution based on the XMI representation of the UML model as taught by Deeptimahanti et al. to the disclosed invention of Brunel et al.
One of ordinary skill in the art would have been motivated to make this modification because "UMGAR has several advantages … [including] addressing the problems caused by lack of domain knowledge by using efficient NLP tools … [and to be] able to visualize UML diagrams in any UML modeling tool that has XMI import feature" (Deeptimahanti et al. Section 5, first paragraph).
Regarding Claim 15,
Brunel et al. in view of Deeptimahanti et al. teaches the computer program product of claim 14.
In addition, Brunel et al. further teaches wherein the program instructions further cause the computer to: perform an automated alignment of model elements in UML diagrams of the UML model ([0045]: "The graphical programming or modeling environment enables graphical modeling of the behavior of the UML model so that the model can be executed in the graphical programming or modeling environment. Execution may be realized by running of code that results from code generation or by interpreting the model. Different versions of code can be automatically generated from the graphical action language and deployment artifacts of the corresponding elements of the UML model. A deployment artifact is a combination of requirements and instructions for compiling and/or executing the UML model" teaches that the graphical programming or modeling environment (e.g. implemented by the computer) automatically generates code from deployment artifacts of the corresponding elements of the UML model (model elements in UML diagrams of the UML model). [0051]: "the graphical programming or modeling environment may generate a sequence diagram automatically from the interpreted, compiled, or mixed execution of the model. The sequence diagram is one of the UML interaction models" teaches that the graphical programming or modeling environment (e.g. implemented by the computer) automatically generates a sequence diagram (e.g. automatically aligns) UML diagrams of the UML model. Fig. 1; [0083]: "The graphical programming or modeling environment 8 receives the UML model and binds its elements to the specification of the UML model or the components of the UML model to represent the UML model or the components of the UML model in the graphical programming or modeling environment 8" teaches that the graphical programming or modeling environment (e.g. implemented by the computer) binds/aligns elements (model elements in UML diagrams) of the UML model).
Regarding Claim 19,
Brunel et al. in view of Deeptimahanti et al. teaches the computer program product of claim 14.
In addition, Deeptimahanti et al. further teaches wherein the program instructions further cause the computer to: import the XMI representation of the UML model corresponding to the architecture solution into an architecture modeling tool (Section 2.4, first paragraph: "To address existing limitations, UMGAR makes following contributions aimed to support automatic generation of possible UML models from SRS written in natural language without need of extensive domain expertise and user interaction: ... It provides a XMI parser to generate XMI file and can be visualized in any UML modeling tool which has XMI import feature" teaches that the generated XMI file (XMI representation) of the UML model is imported into a UML modeling tool (architecture modeling tool)); and
verify compatibility of the XMI representation of the UML model corresponding to the architecture solution with the architecture modeling tool (Section 4.5, first paragraph: "UMGAR provides an efficient XMI parser to support the visualization and manipulation of the generated models in any modeling tool, which has XMI import feature. The XMI file [12] generated by UMGAR’s parser follows XMI v2.1 specifications. This parser is currently supporting all models generated by UMGAR. Models can be modified after imported into modeling tool. We have successfully tested this XMI parser over Argo-UML [36] and Enterprise Architect [35] UML modeling tools" teaches generating the UML model based on the XMI file (XMI representation) corresponding to the UML model, the XMI file (XMI representation) being imported into a UML modeling tool (architecture modeling tool). Section 5, first paragraph: "We have presented and discussed various features of UMGAR by using “Qualification Verification System (QVS)” case system. Our results are quite encouraging in terms of automatic identification of OO elements found from the case systems by UMGAR. UMGAR is also able to visualize UML diagrams in any UML modeling tool that has XMI import feature" teaches that UMGAR uses a verification system for the generated XMI file (XMI representation) of the UML model that is imported into a UML modeling tool (architecture modeling tool)).
Brunel et al. and Deeptimahanti et al. are analogous to the claimed invention because they are directed towards the implementation of XMI representations of UML models.
It would have been obvious to one of ordinary skill in the art before the effective filing date of the claimed invention to incorporate wherein the program instructions further cause the computer to: import the XMI representation of the UML model corresponding to the architecture solution into an architecture modeling tool; and verify compatibility of the XMI representation of the UML model corresponding to the architecture solution with the architecture modeling tool as taught by Deeptimahanti et al. to the disclosed invention of Brunel et al.
One of ordinary skill in the art would have been motivated to make this modification because "UMGAR has several advantages … [including] addressing the problems caused by lack of domain knowledge by using efficient NLP tools … [and to be] able to visualize UML diagrams in any UML modeling tool that has XMI import feature" (Deeptimahanti et al. Section 5, first paragraph).
Regarding Claim 20,
Brunel et al. in view of Deeptimahanti et al. teaches the computer program product of claim 14.
In addition, Brunel et al. further teaches wherein the program instructions further cause the computer to: receive a set of project-specific architecture solution needs corresponding to the architecture solution from a user via a client device ([0044]-[0045]: "The graphical programming or modeling environment enables a user to edit a UML model. Editing the UML model may include adding new modeling elements such as interaction models that show an exchange of messages between run-time objects. In another embodiment of the invention, editing the UML model may involve adding tag-value pairs to one or more UML modeling elements to hold extra information such as information resulting from the graphical modeling and execution activities. In yet another embodiment of the invention, editing the UML model may involve modifying existing model elements, such as existing tagged values, and datatypes of operation ... The graphical programming or modeling environment enables graphical modeling of the behavior of the UML model so that the model can be executed in the graphical programming or modeling environment. Execution may be realized by running of code that results from code generation or by interpreting the model. Different versions of code can be automatically generated from the graphical action language and deployment artifacts of the corresponding elements of the UML model. A deployment artifact is a combination of requirements and instructions for compiling and/or executing the UML model" teaches that the graphical programming or modeling environment (e.g. implemented by the computer) receives user input for modelling the UML model including deployment artifacts (project-specific architecture solution needs) that comprise a combination of requirements and instructions for compiling and/or executing the UML model);
perform an analysis of the set of project-specific architecture solution needs corresponding to the architecture solution received from the user via the client device ([0044]-[0045]: "The graphical programming or modeling environment enables a user to edit a UML model. Editing the UML model may include adding new modeling elements such as interaction models that show an exchange of messages between run-time objects. In another embodiment of the invention, editing the UML model may involve adding tag-value pairs to one or more UML modeling elements to hold extra information such as information resulting from the graphical modeling and execution activities. In yet another embodiment of the invention, editing the UML model may involve modifying existing model elements, such as existing tagged values, and datatypes of operation ... The graphical programming or modeling environment enables graphical modeling of the behavior of the UML model so that the model can be executed in the graphical programming or modeling environment. Execution may be realized by running of code that results from code generation or by interpreting the model. Different versions of code can be automatically generated from the graphical action language and deployment artifacts of the corresponding elements of the UML model. A deployment artifact is a combination of requirements and instructions for compiling and/or executing the UML model" teaches that the graphical programming or modeling environment (e.g. implemented by the computer) receives user input for modelling the UML model including deployment artifacts (project-specific architecture solution needs) that comprise a combination of requirements and instructions for compiling and/or executing the UML model. [0020]: "the action language is used for coverage analysis to identify which elements of a model have been evaluated during a set of executions. In yet another aspect, the action language is used to analyze the time it takes for model elements to be evaluated. This timing analysis can be used to schedule the execution of model elements so as to achieve real-time behavior on a given computing platform. In a further aspect, the action language is used to automatically generate tests that contain input values to the model. The generated tests are generated so as to invoke certain behavior of the model or so as to enforce evaluation of certain model elements" teaches that the action language and deployment artifacts (project-specific architecture solution needs) is used for performing an analysis corresponding to the model (architecture solution)); and
convert, using a foundation model, the set of project-specific architecture solution needs corresponding to the architecture solution into the set of instructions in the predefined format based on the analysis of the set of project-specific architecture solution needs ([0044]-[0045]: "The graphical programming or modeling environment enables a user to edit a UML model. Editing the UML model may include adding new modeling elements such as interaction models that show an exchange of messages between run-time objects. In another embodiment of the invention, editing the UML model may involve adding tag-value pairs to one or more UML modeling elements to hold extra information such as information resulting from the graphical modeling and execution activities. In yet another embodiment of the invention, editing the UML model may involve modifying existing model elements, such as existing tagged values, and datatypes of operation ... The graphical programming or modeling environment enables graphical modeling of the behavior of the UML model so that the model can be executed in the graphical programming or modeling environment. Execution may be realized by running of code that results from code generation or by interpreting the model. Different versions of code can be automatically generated from the graphical action language and deployment artifacts of the corresponding elements of the UML model. A deployment artifact is a combination of requirements and instructions for compiling and/or executing the UML model" teaches that the graphical programming or modeling environment (e.g. implemented by the computer) receives user input for modelling the UML model including deployment artifacts (project-specific architecture solution needs) that comprise a combination of requirements and instructions for compiling and/or executing the UML model. [0051]: "the graphical programming or modeling environment may generate a sequence diagram automatically from the interpreted, compiled, or mixed execution of the model. The sequence diagram is one of the UML interaction models. The generated sequence diagram may be converted into a text-based format, such as the XML format, and merged into the text-based XMI format of the UML component model so that the UML source model contains the component diagram and the sequence diagram" teaches the XMI of the UML model corresponding to the model sequence diagram (architecture solution) based on a text-based format (predefined format). Fig. 1; [0068]: "The abstract model 5 can be exported into a text-based data format 6. The text-based data format 6 may contain information on the graphical and non-graphical aspects of the model 5. The text-based data format 6 may be described using the XML Metadata Interface (XMI) format" teaches that the XMI representation of the abstract (UML) model is based on information on the graphical and non-graphical aspects of the model (project-specific architecture solution needs) in a text-based data format (instructions in a predefined format)).
Claims 3, 11, and 16 are rejected under 35 U.S.C. 103 as being unpatentable over Brunel et al. (US 2007/0277151 A1) in view of Deeptimahanti et al. ("Semi-automatic generation of UML models from natural language requirements") and further in view of Savary-Leblanc et al. ("The Modeling Assistant Recommender: A UML class diagram recommender system").
Regarding Claim 3,
Brunel et al. in view of Deeptimahanti et al. teaches the computer-implemented method of claim 1.
In addition, Brunel et al. further teaches further comprising: validating, by the computer, the UML model corresponding to the architecture solution based on a set of standard UML model validation rules and a set of UML model validation rules specific to the architecture solution ([0049]: "The alternative embodiment of the present invention may also generate, optimize and validate the implementation code of a UML component that incorporates the numerical and temporal behavior of the model" teaches validating the UML model corresponding to the architecture solution. [0051]-[0052]: "the graphical programming or modeling environment may generate a sequence diagram automatically from the interpreted, compiled, or mixed execution of the model. The sequence diagram is one of the UML interaction models ... a sequence diagram that is part of the UML model is automatically converted into a set of input signals to the behavioral model. The sequence diagram as it is part of the UML model may associate behavioral input to a temporal sequence of message exchange. This sequence can be directly used as input during execution (either interpreted, compiled, or mixed) of the behavior model, while the dependent activities in the sequence diagram emerge during the execution and can be validated against the original sequence diagram" teaches that validating the UML model is based on an original sequence diagram generated from the interpreted, compiled, or mixed execution of the model (e.g. generated from UML model rules and rules specific to the model architecture solution). [0045]: "The graphical programming or modeling environment enables graphical modeling of the behavior of the UML model so that the model can be executed in the graphical programming or modeling environment. Execution may be realized by running of code that results from code generation or by interpreting the model. Different versions of code can be automatically generated from the graphical action language and deployment artifacts of the corresponding elements of the UML model. A deployment artifact is a combination of requirements and instructions for compiling and/or executing the UML model" teaches that the interpreted, compiled, or mixed execution of the model used for generating the original sequence diagram of the UML model used for validation are based on requirements and instructions for the model architecture (e.g. UML model rules and rules specific to the model architecture solution)).
Brunel et al. in view of Deeptimahanti et al. does not appear to explicitly teach ranking, by the computer, the UML model corresponding to the architecture solution based on a set of principles and standards defined for the architecture solution.
However, Savary-Leblanc et al. teaches ranking, by the computer, the UML model corresponding to the architecture solution based on a set of principles and standards defined for the architecture solution (Section 1, last paragraph: "we explored modeling assistance investigating how to propose element completion when editing diagrams, similar to source code recommenders. More specifically, we studied recommendations about completing UML class diagrams (e.g., a model subset) by proposing UML elements ranked by a confidence score. The recommendations are created by extracting features from a model data set and combining them into a score, as our approach explores how to exploit a model repository to complete one specific diagram" teaches ranking the UML elements (UML model) of the model architecture based on a confidence score based on extracted feature from a model data set (i.e. the confidence score based on extracted features of the model data corresponds to principles and standards for the model architecture solution)).
Brunel et al., Deeptimahanti et al., and Savary-Leblanc et al. are analogous to the claimed invention because they are directed towards the implementation of XMI representations of UML models.
It would have been obvious to one of ordinary skill in the art before the effective filing date of the claimed invention to incorporate ranking, by the computer, the UML model corresponding to the architecture solution based on a set of principles and standards defined for the architecture solution as taught by Savary-Leblanc et al. to the disclosed invention of Brunel et al. in view of Deeptimahanti et al.
One of ordinary skill in the art would have been motivated to make this modification "to increase the range of functionalities proposed by the modeling environments … [and] to enable the current tools to embed assistance features relying on the meaning of the model elements they manipulate thanks to the available knowledge" (Savary-Leblanc et al. Section 5).
Regarding Claim 11,
Brunel et al. in view of Deeptimahanti et al. teaches the computer system of claim 9.
In addition, Brunel et al. further teaches wherein the set of processors further executes the program instructions to: validate the UML model corresponding to the architecture solution based on a set of standard UML model validation rules and a set of UML model validation rules specific to the architecture solution ([0049]: "The alternative embodiment of the present invention may also generate, optimize and validate the implementation code of a UML component that incorporates the numerical and temporal behavior of the model" teaches validating the UML model corresponding to the architecture solution. [0051]-[0052]: "the graphical programming or modeling environment may generate a sequence diagram automatically from the interpreted, compiled, or mixed execution of the model. The sequence diagram is one of the UML interaction models ... a sequence diagram that is part of the UML model is automatically converted into a set of input signals to the behavioral model. The sequence diagram as it is part of the UML model may associate behavioral input to a temporal sequence of message exchange. This sequence can be directly used as input during execution (either interpreted, compiled, or mixed) of the behavior model, while the dependent activities in the sequence diagram emerge during the execution and can be validated against the original sequence diagram" teaches that validating the UML model is based on an original sequence diagram generated from the interpreted, compiled, or mixed execution of the model (e.g. generated from UML model rules and rules specific to the model architecture solution). [0045]: "The graphical programming or modeling environment enables graphical modeling of the behavior of the UML model so that the model can be executed in the graphical programming or modeling environment. Execution may be realized by running of code that results from code generation or by interpreting the model. Different versions of code can be automatically generated from the graphical action language and deployment artifacts of the corresponding elements of the UML model. A deployment artifact is a combination of requirements and instructions for compiling and/or executing the UML model" teaches that the interpreted, compiled, or mixed execution of the model used for generating the original sequence diagram of the UML model used for validation are based on requirements and instructions for the model architecture (e.g. UML model rules and rules specific to the model architecture solution)).
Brunel et al. in view of Deeptimahanti et al. does not appear to explicitly teach rank the UML model corresponding to the architecture solution based on a set of principles and standards defined for the architecture solution.
However, Savary-Leblanc et al. teaches rank the UML model corresponding to the architecture solution based on a set of principles and standards defined for the architecture solution (Section 1, last paragraph: "we explored modeling assistance investigating how to propose element completion when editing diagrams, similar to source code recommenders. More specifically, we studied recommendations about completing UML class diagrams (e.g., a model subset) by proposing UML elements ranked by a confidence score. The recommendations are created by extracting features from a model data set and combining them into a score, as our approach explores how to exploit a model repository to complete one specific diagram" teaches ranking the UML elements (UML model) of the model architecture based on a confidence score based on extracted feature from a model data set (i.e. the confidence score based on extracted features of the model data corresponds to principles and standards for the model architecture solution)).
Brunel et al., Deeptimahanti et al., and Savary-Leblanc et al. are analogous to the claimed invention because they are directed towards the implementation of XMI representations of UML models.
It would have been obvious to one of ordinary skill in the art before the effective filing date of the claimed invention to incorporate rank the UML model corresponding to the architecture solution based on a set of principles and standards defined for the architecture solution as taught by Savary-Leblanc et al. to the disclosed invention of Brunel et al. in view of Deeptimahanti et al.
One of ordinary skill in the art would have been motivated to make this modification "to increase the range of functionalities proposed by the modeling environments … [and] to enable the current tools to embed assistance features relying on the meaning of the model elements they manipulate thanks to the available knowledge" (Savary-Leblanc et al. Section 5).
Regarding Claim 16,
Brunel et al. in view of Deeptimahanti et al. teaches the computer program product of claim 14.
In addition, Brunel et al. further teaches wherein the program instructions further cause the computer to: validate the UML model corresponding to the architecture solution based on a set of standard UML model validation rules and a set of UML model validation rules specific to the architecture solution ([0049]: "The alternative embodiment of the present invention may also generate, optimize and validate the implementation code of a UML component that incorporates the numerical and temporal behavior of the model" teaches validating the UML model corresponding to the architecture solution. [0051]-[0052]: "the graphical programming or modeling environment may generate a sequence diagram automatically from the interpreted, compiled, or mixed execution of the model. The sequence diagram is one of the UML interaction models ... a sequence diagram that is part of the UML model is automatically converted into a set of input signals to the behavioral model. The sequence diagram as it is part of the UML model may associate behavioral input to a temporal sequence of message exchange. This sequence can be directly used as input during execution (either interpreted, compiled, or mixed) of the behavior model, while the dependent activities in the sequence diagram emerge during the execution and can be validated against the original sequence diagram" teaches that validating the UML model is based on an original sequence diagram generated from the interpreted, compiled, or mixed execution of the model (e.g. generated from UML model rules and rules specific to the model architecture solution). [0045]: "The graphical programming or modeling environment enables graphical modeling of the behavior of the UML model so that the model can be executed in the graphical programming or modeling environment. Execution may be realized by running of code that results from code generation or by interpreting the model. Different versions of code can be automatically generated from the graphical action language and deployment artifacts of the corresponding elements of the UML model. A deployment artifact is a combination of requirements and instructions for compiling and/or executing the UML model" teaches that the interpreted, compiled, or mixed execution of the model used for generating the original sequence diagram of the UML model used for validation are based on requirements and instructions for the model architecture (e.g. UML model rules and rules specific to the model architecture solution)).
Brunel et al. in view of Deeptimahanti et al. does not appear to explicitly teach rank the UML model corresponding to the architecture solution based on a set of principles and standards defined for the architecture solution.
However, Savary-Leblanc et al. teaches rank the UML model corresponding to the architecture solution based on a set of principles and standards defined for the architecture solution (Section 1, last paragraph: "we explored modeling assistance investigating how to propose element completion when editing diagrams, similar to source code recommenders. More specifically, we studied recommendations about completing UML class diagrams (e.g., a model subset) by proposing UML elements ranked by a confidence score. The recommendations are created by extracting features from a model data set and combining them into a score, as our approach explores how to exploit a model repository to complete one specific diagram" teaches ranking the UML elements (UML model) of the model architecture based on a confidence score based on extracted feature from a model data set (i.e. the confidence score based on extracted features of the model data corresponds to principles and standards for the model architecture solution)).
Brunel et al., Deeptimahanti et al., and Savary-Leblanc et al. are analogous to the claimed invention because they are directed towards the implementation of XMI representations of UML models.
It would have been obvious to one of ordinary skill in the art before the effective filing date of the claimed invention to incorporate rank the UML model corresponding to the architecture solution based on a set of principles and standards defined for the architecture solution as taught by Savary-Leblanc et al. to the disclosed invention of Brunel et al. in view of Deeptimahanti et al.
One of ordinary skill in the art would have been motivated to make this modification "to increase the range of functionalities proposed by the modeling environments … [and] to enable the current tools to embed assistance features relying on the meaning of the model elements they manipulate thanks to the available knowledge" (Savary-Leblanc et al. Section 5).
Claims 4-5, 12-13, and 17-18 are rejected under 35 U.S.C. 103 as being unpatentable over Brunel et al. (US 2007/0277151 A1) in view of Deeptimahanti et al. ("Semi-automatic generation of UML models from natural language requirements") in view of Savary-Leblanc et al. ("The Modeling Assistant Recommender: A UML class diagram recommender system") and further in view of Alazba et al. ("Automated detection of class diagram smells using self-supervised learning").
Regarding Claim 4,
Brunel et al. in view of Deeptimahanti et al. teaches the computer-implemented method of claim 1.
In addition, Brunel et al. further teaches further comprising: generating, by the computer, an XMI representation compatibility report, a UML model validation report, … for the UML model corresponding to the architecture solution ([0041]: "debugging and profiling of the execution of a UML model that has a realization in the action language can be performed … Profiling involves reporting on the computational cycles spent on evaluating model elements. The reports generated by profiling can be hierarchically structured and can provide, for example, insight as to where execution of a model may be optimized" teaches generating reports for the UML model based on the execution of the model. [0049]: "The alternative embodiment of the present invention may also generate, optimize and validate the implementation code of a UML component that incorporates the numerical and temporal behavior of the model" teaches validating the UML model corresponding to the architecture solution. [0051]-[0052]: "the graphical programming or modeling environment may generate a sequence diagram automatically from the interpreted, compiled, or mixed execution of the model. The sequence diagram is one of the UML interaction models. The generated sequence diagram may be converted into a text-based format, such as the XML format, and merged into the text-based XMI format of the UML component model so that the UML source model contains the component diagram and the sequence diagram ... a sequence diagram that is part of the UML model is automatically converted into a set of input signals to the behavioral model. The sequence diagram as it is part of the UML model may associate behavioral input to a temporal sequence of message exchange. This sequence can be directly used as input during execution (either interpreted, compiled, or mixed) of the behavior model, while the dependent activities in the sequence diagram emerge during the execution and can be validated against the original sequence diagram" teaches that the model execution includes using the XMI representation of the UML model and validating the UML model based on an original sequence diagram generated from the interpreted, compiled, or mixed execution of the model (e.g. the UML model is based on the XMI representation and validated during execution, so the reports generated based on model execution include an XMI representation compatibility report and a UML model validation report)).
Brunel et al. in view of Deeptimahanti et al. does not appear to explicitly teach further comprising: generating, by the computer, … a UML model rank report for the UML model corresponding to the architecture solution; and inputting, by the computer, the XMI representation compatibility report, the UML model validation report, and the UML model rank report into a foundation model to retrain the foundation model via self-learning to increase accuracy of generating XMI representations of UML models.
However, Savary-Leblanc et al. teaches generating, by the computer, … a UML model rank report for the UML model corresponding to the architecture solution (Section 1, last paragraph: "we explored modeling assistance investigating how to propose element completion when editing diagrams, similar to source code recommenders. More specifically, we studied recommendations about completing UML class diagrams (e.g., a model subset) by proposing UML elements ranked by a confidence score. The recommendations are created by extracting features from a model data set and combining them into a score, as our approach explores how to exploit a model repository to complete one specific diagram" teaches generating a recommendation (UML model rank report) based on ranking the UML elements (UML model) of the model architecture).
Brunel et al., Deeptimahanti et al., and Savary-Leblanc et al. are analogous to the claimed invention because they are directed towards the implementation of XMI representations of UML models.
It would have been obvious to one of ordinary skill in the art before the effective filing date of the claimed invention to incorporate generating, by the computer, … a UML model rank report for the UML model corresponding to the architecture solution as taught by Savary-Leblanc et al. to the disclosed invention of Brunel et al. in view of Deeptimahanti et al.
One of ordinary skill in the art would have been motivated to make this modification "to increase the range of functionalities proposed by the modeling environments … [and] to enable the current tools to embed assistance features relying on the meaning of the model elements they manipulate thanks to the available knowledge" (Savary-Leblanc et al. Section 5).
Brunel et al. in view of Deeptimahanti et al. and further in view of Savary-Leblanc et al. does not appear to explicitly teach inputting, by the computer, the XMI representation compatibility report, the UML model validation report, and the UML model rank report into a foundation model to retrain the foundation model via self-learning to increase accuracy of generating XMI representations of UML models.
However, Alazba et al. teaches inputting, by the computer, the XMI representation compatibility report, the UML model validation report, and the UML model rank report into a foundation model to retrain the foundation model via self-learning to increase accuracy of generating XMI representations of UML models (Fig. 2; Section 3 - Section 3.1.1, first paragraph: "The paper introduces a novel self-supervised learning approach, called MoRT ... MoRT leverages unsupervised semantic feature learning to learn meaningful representations of class diagrams automatically without manual annotations ... We present the implementation details of MoRT in this section. An overview of our framework is shown in Fig. 2. As illustrated in the figure, there are two main steps: 1) pre-training, where we utilize the unlabeled datasets to train various DL models on pre-defined tasks, and 2) fine-tuning, in which several tasks are considered to fine-tune the pre-trained model ... MoRT is trained to predict a set of masked words applied to a part of the XMI representation of the UML Class Diagram that is given to it as input" teaches a self-supervised learning (self-learning) MoRT model (foundation model) for generating an XMI representation of a UML model. Section 5.3, fourth paragraph: "MoRT fine-tunes all layers of the pre-trained model on the target dataset, which increases the detection performance of the target dataset, as discussed in the previous section, where MoRT performed better than the feature-based model" teaches that the MoRT model (foundation model) is fine-tuned (retrained) based on performance (e.g. based on the reports). Section 7.1: "The selection of the validation method may affect the conclusion of this study ... We employed several measures that are often used in the literature to mitigate the risk of bias, including accuracy, recall, f-score, precision, MCC, and AUC" teaches that the performance evaluation metrics for the model for validation (e.g. based on the reports) include accuracy (i.e. the self-learning fine-tuning to increase performance validation includes performance metrics including accuracy)).
Brunel et al., Deeptimahanti et al., Savary-Leblanc et al., and Alazba et al. are analogous to the claimed invention because they are directed towards the implementation of XMI representations of UML models.
It would have been obvious to one of ordinary skill in the art before the effective filing date of the claimed invention to incorporate inputting, by the computer, the XMI representation compatibility report, the UML model validation report, and the UML model rank report into a foundation model to retrain the foundation model via self-learning to increase accuracy of generating XMI representations of UML models as taught by Alazba et al. to the disclosed invention of Brunel et al. in view of Deeptimahanti et al. and further in view of Savary-Leblanc et al.
One of ordinary skill in the art would have been motivated to make this modification because "this approach eliminates the need for manual annotations, improving detection efficiency and reducing costs" (Alazba et al. Section 2, last paragraph).
Regarding Claim 5,
Brunel et al. in view of Deeptimahanti et al. in view of Savary-Leblanc et al. and further in view of Alazba et al. teaches the method of claim 5.
In addition, Brunel et al. further teaches further comprising: sending, by the computer, the XMI representation compatibility report, the UML model validation report, and the UML model rank report to a user via a client device ([0041]: "debugging and profiling of the execution of a UML model that has a realization in the action language can be performed … Profiling involves reporting on the computational cycles spent on evaluating model elements. The reports generated by profiling can be hierarchically structured and can provide, for example, insight as to where execution of a model may be optimized" teaches generating reports for the UML model based on the execution of the model. [0049]-[0050]: "The alternative embodiment of the present invention may also generate, optimize and validate the implementation code of a UML component that incorporates the numerical and temporal behavior of the model ... the graphical programming or modeling environment may simulate a UML deployment diagram that enables a user to assess performance, load, reliability, and schedulability requirements of the run-time processing nodes against the time and numerical resolution of control and signal-processing algorithms with safety and reliability constraints" teaches validating the UML model corresponding to the architecture solution and that a user is provided reports about the UML model (e.g. the user is sent the XMI representation compatibility report, the UML model validation report, and the UML model rank report). Fig. 3; [0075]-[0078]: "the client 26 may include a UML modeling environment 4 that enables a user to build a UML model ... The client 27 may include the graphical programming or modeling environment 8 that enables a user to build and simulate/execute a block diagram model" teaches that the user is sent the UML model reports via a client device); and
implementing, by the computer, the architecture solution in an environment corresponding to the user in response to receiving an input from the user to implement the architecture solution based on the XMI representation compatibility report, the UML model validation report, and the UML model rank report ([0041]: "debugging and profiling of the execution of a UML model that has a realization in the action language can be performed … Profiling involves reporting on the computational cycles spent on evaluating model elements. The reports generated by profiling can be hierarchically structured and can provide, for example, insight as to where execution of a model may be optimized" teaches generating reports for the UML model based on the execution of the model. [0049]-[0050]: "The alternative embodiment of the present invention may also generate, optimize and validate the implementation code of a UML component that incorporates the numerical and temporal behavior of the model ... the graphical programming or modeling environment may simulate a UML deployment diagram that enables a user to assess performance, load, reliability, and schedulability requirements of the run-time processing nodes against the time and numerical resolution of control and signal-processing algorithms with safety and reliability constraints" teaches validating the UML model corresponding to the architecture solution and that a user is provided reports about the UML model (e.g. the user is sent the XMI representation compatibility report, the UML model validation report, and the UML model rank report). [0058]-[0059]: "a graphical programming or modeling environment enables a user to graphically program the behavior of a Unified Modeling Language (UML) model. The graphical programming or modeling environment represents a software or hardware system as a collection of blocks interconnected by lines. Blocks are entities of the system that perform given functions in the system ... a UML model may be exported into a text-based format, such as the XML Metadata Interface (XMI) format. The graphical programming or modeling environment may import the UML model and represent the UML model using behavioral blocks provided in the graphical programming or modeling environment. The illustrative embodiment may provide a publishing tool for representing the components of the UML model using hierarchical functional blocks in the graphical programming or modeling environment. The graphical programming or modeling environment enables a user or programmer to graphically define the behaviors of the UML model so that the UML model can be executed. The UML model can be modified based on the execution results" teaches that the UML model architecture solution is implemented in an environment corresponding to the user in response to user input based on the execution reports of the UML model).
Regarding Claim 12,
Brunel et al. in view of Deeptimahanti et al. teaches the computer system of claim 9.
In addition, Brunel et al. further teaches wherein the set of processors further executes the program instructions to: generate an XMI representation compatibility report, a UML model validation report … for the UML model corresponding to the architecture solution ([0041]: "debugging and profiling of the execution of a UML model that has a realization in the action language can be performed … Profiling involves reporting on the computational cycles spent on evaluating model elements. The reports generated by profiling can be hierarchically structured and can provide, for example, insight as to where execution of a model may be optimized" teaches generating reports for the UML model based on the execution of the model. [0049]: "The alternative embodiment of the present invention may also generate, optimize and validate the implementation code of a UML component that incorporates the numerical and temporal behavior of the model" teaches validating the UML model corresponding to the architecture solution. [0051]-[0052]: "the graphical programming or modeling environment may generate a sequence diagram automatically from the interpreted, compiled, or mixed execution of the model. The sequence diagram is one of the UML interaction models. The generated sequence diagram may be converted into a text-based format, such as the XML format, and merged into the text-based XMI format of the UML component model so that the UML source model contains the component diagram and the sequence diagram ... a sequence diagram that is part of the UML model is automatically converted into a set of input signals to the behavioral model. The sequence diagram as it is part of the UML model may associate behavioral input to a temporal sequence of message exchange. This sequence can be directly used as input during execution (either interpreted, compiled, or mixed) of the behavior model, while the dependent activities in the sequence diagram emerge during the execution and can be validated against the original sequence diagram" teaches that the model execution includes using the XMI representation of the UML model and validating the UML model based on an original sequence diagram generated from the interpreted, compiled, or mixed execution of the model (e.g. the UML model is based on the XMI representation and validated during execution, so the reports generated based on model execution include an XMI representation compatibility report and a UML model validation report)).
Brunel et al. in view of Deeptimahanti et al. does not appear to explicitly teach generate … a UML model rank report for the UML model corresponding to the architecture solution; and input the XMI representation compatibility report, the UML model validation report, and the UML model rank report into a foundation model to retrain the foundation model via self-learning to increase accuracy of generating XMI representations of UML models.
However, Savary-Leblanc et al. teaches generate … a UML model rank report for the UML model corresponding to the architecture solution (Section 1, last paragraph: "we explored modeling assistance investigating how to propose element completion when editing diagrams, similar to source code recommenders. More specifically, we studied recommendations about completing UML class diagrams (e.g., a model subset) by proposing UML elements ranked by a confidence score. The recommendations are created by extracting features from a model data set and combining them into a score, as our approach explores how to exploit a model repository to complete one specific diagram" teaches generating a recommendation (UML model rank report) based on ranking the UML elements (UML model) of the model architecture).
Brunel et al., Deeptimahanti et al., and Savary-Leblanc et al. are analogous to the claimed invention because they are directed towards the implementation of XMI representations of UML models.
It would have been obvious to one of ordinary skill in the art before the effective filing date of the claimed invention to incorporate generate … a UML model rank report for the UML model corresponding to the architecture solution as taught by Savary-Leblanc et al. to the disclosed invention of Brunel et al. in view of Deeptimahanti et al.
One of ordinary skill in the art would have been motivated to make this modification "to increase the range of functionalities proposed by the modeling environments … [and] to enable the current tools to embed assistance features relying on the meaning of the model elements they manipulate thanks to the available knowledge" (Savary-Leblanc et al. Section 5).
Brunel et al. in view of Deeptimahanti et al. and further in view of Savary-Leblanc et al. does not appear to explicitly teach input the XMI representation compatibility report, the UML model validation report, and the UML model rank report into a foundation model to retrain the foundation model via self-learning to increase accuracy of generating XMI representations of UML models.
However, Alazba et al. teaches input the XMI representation compatibility report, the UML model validation report, and the UML model rank report into a foundation model to retrain the foundation model via self-learning to increase accuracy of generating XMI representations of UML models (Fig. 2; Section 3 - Section 3.1.1, first paragraph: "The paper introduces a novel self-supervised learning approach, called MoRT ... MoRT leverages unsupervised semantic feature learning to learn meaningful representations of class diagrams automatically without manual annotations ... We present the implementation details of MoRT in this section. An overview of our framework is shown in Fig. 2. As illustrated in the figure, there are two main steps: 1) pre-training, where we utilize the unlabeled datasets to train various DL models on pre-defined tasks, and 2) fine-tuning, in which several tasks are considered to fine-tune the pre-trained model ... MoRT is trained to predict a set of masked words applied to a part of the XMI representation of the UML Class Diagram that is given to it as input" teaches a self-supervised learning (self-learning) MoRT model (foundation model) for generating an XMI representation of a UML model. Section 5.3, fourth paragraph: "MoRT fine-tunes all layers of the pre-trained model on the target dataset, which increases the detection performance of the target dataset, as discussed in the previous section, where MoRT performed better than the feature-based model" teaches that the MoRT model (foundation model) is fine-tuned (retrained) based on performance (e.g. based on the reports). Section 7.1: "The selection of the validation method may affect the conclusion of this study ... We employed several measures that are often used in the literature to mitigate the risk of bias, including accuracy, recall, f-score, precision, MCC, and AUC" teaches that the performance evaluation metrics for the model for validation (e.g. based on the reports) include accuracy (i.e. the self-learning fine-tuning to increase performance validation includes performance metrics including accuracy)).
Brunel et al., Deeptimahanti et al., Savary-Leblanc et al., and Alazba et al. are analogous to the claimed invention because they are directed towards the implementation of XMI representations of UML models.
It would have been obvious to one of ordinary skill in the art before the effective filing date of the claimed invention to incorporate input the XMI representation compatibility report, the UML model validation report, and the UML model rank report into a foundation model to retrain the foundation model via self-learning to increase accuracy of generating XMI representations of UML models as taught by Alazba et al. to the disclosed invention of Brunel et al. in view of Deeptimahanti et al. and further in view of Savary-Leblanc et al.
One of ordinary skill in the art would have been motivated to make this modification because "this approach eliminates the need for manual annotations, improving detection efficiency and reducing costs" (Alazba et al. Section 2, last paragraph).
Regarding Claim 13,
Brunel et al. in view of Deeptimahanti et al. in view of Savary-Leblanc et al. and further in view of Alazba et al. teaches the computer system of claim 12.
In addition, Brunel et al. further teaches wherein the set of processors further executes the program instructions to: send the XMI representation compatibility report, the UML model validation report, and the UML model rank report to a user via a client device ([0041]: "debugging and profiling of the execution of a UML model that has a realization in the action language can be performed … Profiling involves reporting on the computational cycles spent on evaluating model elements. The reports generated by profiling can be hierarchically structured and can provide, for example, insight as to where execution of a model may be optimized" teaches generating reports for the UML model based on the execution of the model. [0049]-[0050]: "The alternative embodiment of the present invention may also generate, optimize and validate the implementation code of a UML component that incorporates the numerical and temporal behavior of the model ... the graphical programming or modeling environment may simulate a UML deployment diagram that enables a user to assess performance, load, reliability, and schedulability requirements of the run-time processing nodes against the time and numerical resolution of control and signal-processing algorithms with safety and reliability constraints" teaches validating the UML model corresponding to the architecture solution and that a user is provided reports about the UML model (e.g. the user is sent the XMI representation compatibility report, the UML model validation report, and the UML model rank report). Fig. 3; [0075]-[0078]: "the client 26 may include a UML modeling environment 4 that enables a user to build a UML model ... The client 27 may include the graphical programming or modeling environment 8 that enables a user to build and simulate/execute a block diagram model" teaches that the user is sent the UML model reports via a client device); and
implement the architecture solution in an environment corresponding to the user in response to receiving an input from the user to implement the architecture solution based on the XMI representation compatibility report, the UML model validation report, and the UML model rank report ([0041]: "debugging and profiling of the execution of a UML model that has a realization in the action language can be performed … Profiling involves reporting on the computational cycles spent on evaluating model elements. The reports generated by profiling can be hierarchically structured and can provide, for example, insight as to where execution of a model may be optimized" teaches generating reports for the UML model based on the execution of the model. [0049]-[0050]: "The alternative embodiment of the present invention may also generate, optimize and validate the implementation code of a UML component that incorporates the numerical and temporal behavior of the model ... the graphical programming or modeling environment may simulate a UML deployment diagram that enables a user to assess performance, load, reliability, and schedulability requirements of the run-time processing nodes against the time and numerical resolution of control and signal-processing algorithms with safety and reliability constraints" teaches validating the UML model corresponding to the architecture solution and that a user is provided reports about the UML model (e.g. the user is sent the XMI representation compatibility report, the UML model validation report, and the UML model rank report). [0058]-[0059]: "a graphical programming or modeling environment enables a user to graphically program the behavior of a Unified Modeling Language (UML) model. The graphical programming or modeling environment represents a software or hardware system as a collection of blocks interconnected by lines. Blocks are entities of the system that perform given functions in the system ... a UML model may be exported into a text-based format, such as the XML Metadata Interface (XMI) format. The graphical programming or modeling environment may import the UML model and represent the UML model using behavioral blocks provided in the graphical programming or modeling environment. The illustrative embodiment may provide a publishing tool for representing the components of the UML model using hierarchical functional blocks in the graphical programming or modeling environment. The graphical programming or modeling environment enables a user or programmer to graphically define the behaviors of the UML model so that the UML model can be executed. The UML model can be modified based on the execution results" teaches that the UML model architecture solution is implemented in an environment corresponding to the user in response to user input based on the execution reports of the UML model).
Regarding Claim 17,
Brunel et al. in view of Deeptimahanti et al. teaches the computer program product of claim 14.
In addition, Brunel et al. further teaches wherein the program instructions further cause the computer to: generate an XMI representation compatibility report, a UML model validation report … for the UML model corresponding to the architecture solution ([0041]: "debugging and profiling of the execution of a UML model that has a realization in the action language can be performed … Profiling involves reporting on the computational cycles spent on evaluating model elements. The reports generated by profiling can be hierarchically structured and can provide, for example, insight as to where execution of a model may be optimized" teaches generating reports for the UML model based on the execution of the model. [0049]: "The alternative embodiment of the present invention may also generate, optimize and validate the implementation code of a UML component that incorporates the numerical and temporal behavior of the model" teaches validating the UML model corresponding to the architecture solution. [0051]-[0052]: "the graphical programming or modeling environment may generate a sequence diagram automatically from the interpreted, compiled, or mixed execution of the model. The sequence diagram is one of the UML interaction models. The generated sequence diagram may be converted into a text-based format, such as the XML format, and merged into the text-based XMI format of the UML component model so that the UML source model contains the component diagram and the sequence diagram ... a sequence diagram that is part of the UML model is automatically converted into a set of input signals to the behavioral model. The sequence diagram as it is part of the UML model may associate behavioral input to a temporal sequence of message exchange. This sequence can be directly used as input during execution (either interpreted, compiled, or mixed) of the behavior model, while the dependent activities in the sequence diagram emerge during the execution and can be validated against the original sequence diagram" teaches that the model execution includes using the XMI representation of the UML model and validating the UML model based on an original sequence diagram generated from the interpreted, compiled, or mixed execution of the model (e.g. the UML model is based on the XMI representation and validated during execution, so the reports generated based on model execution include an XMI representation compatibility report and a UML model validation report)).
Brunel et al. in view of Deeptimahanti et al. does not appear to explicitly teach generate … a UML model rank report for the UML model corresponding to the architecture solution; and input the XMI representation compatibility report, the UML model validation report, and the UML model rank report into a foundation model to retrain the foundation model via self-learning to increase accuracy of generating XMI representations of UML models.
However, Savary-Leblanc et al. teaches generate … a UML model rank report for the UML model corresponding to the architecture solution (Section 1, last paragraph: "we explored modeling assistance investigating how to propose element completion when editing diagrams, similar to source code recommenders. More specifically, we studied recommendations about completing UML class diagrams (e.g., a model subset) by proposing UML elements ranked by a confidence score. The recommendations are created by extracting features from a model data set and combining them into a score, as our approach explores how to exploit a model repository to complete one specific diagram" teaches generating a recommendation (UML model rank report) based on ranking the UML elements (UML model) of the model architecture).
Brunel et al., Deeptimahanti et al., and Savary-Leblanc et al. are analogous to the claimed invention because they are directed towards the implementation of XMI representations of UML models.
It would have been obvious to one of ordinary skill in the art before the effective filing date of the claimed invention to incorporate generate … a UML model rank report for the UML model corresponding to the architecture solution as taught by Savary-Leblanc et al. to the disclosed invention of Brunel et al. in view of Deeptimahanti et al.
One of ordinary skill in the art would have been motivated to make this modification "to increase the range of functionalities proposed by the modeling environments … [and] to enable the current tools to embed assistance features relying on the meaning of the model elements they manipulate thanks to the available knowledge" (Savary-Leblanc et al. Section 5).
Brunel et al. in view of Deeptimahanti et al. and further in view of Savary-Leblanc et al. does not appear to explicitly teach input the XMI representation compatibility report, the UML model validation report, and the UML model rank report into a foundation model to retrain the foundation model via self-learning to increase accuracy of generating XMI representations of UML models.
However, Alazba et al. teaches input the XMI representation compatibility report, the UML model validation report, and the UML model rank report into a foundation model to retrain the foundation model via self-learning to increase accuracy of generating XMI representations of UML models (Fig. 2; Section 3 - Section 3.1.1, first paragraph: "The paper introduces a novel self-supervised learning approach, called MoRT ... MoRT leverages unsupervised semantic feature learning to learn meaningful representations of class diagrams automatically without manual annotations ... We present the implementation details of MoRT in this section. An overview of our framework is shown in Fig. 2. As illustrated in the figure, there are two main steps: 1) pre-training, where we utilize the unlabeled datasets to train various DL models on pre-defined tasks, and 2) fine-tuning, in which several tasks are considered to fine-tune the pre-trained model ... MoRT is trained to predict a set of masked words applied to a part of the XMI representation of the UML Class Diagram that is given to it as input" teaches a self-supervised learning (self-learning) MoRT model (foundation model) for generating an XMI representation of a UML model. Section 5.3, fourth paragraph: "MoRT fine-tunes all layers of the pre-trained model on the target dataset, which increases the detection performance of the target dataset, as discussed in the previous section, where MoRT performed better than the feature-based model" teaches that the MoRT model (foundation model) is fine-tuned (retrained) based on performance (e.g. based on the reports). Section 7.1: "The selection of the validation method may affect the conclusion of this study ... We employed several measures that are often used in the literature to mitigate the risk of bias, including accuracy, recall, f-score, precision, MCC, and AUC" teaches that the performance evaluation metrics for the model for validation (e.g. based on the reports) include accuracy (i.e. the self-learning fine-tuning to increase performance validation includes performance metrics including accuracy)).
Brunel et al., Deeptimahanti et al., Savary-Leblanc et al., and Alazba et al. are analogous to the claimed invention because they are directed towards the implementation of XMI representations of UML models.
It would have been obvious to one of ordinary skill in the art before the effective filing date of the claimed invention to incorporate input the XMI representation compatibility report, the UML model validation report, and the UML model rank report into a foundation model to retrain the foundation model via self-learning to increase accuracy of generating XMI representations of UML models as taught by Alazba et al. to the disclosed invention of Brunel et al. in view of Deeptimahanti et al. and further in view of Savary-Leblanc et al.
One of ordinary skill in the art would have been motivated to make this modification because "this approach eliminates the need for manual annotations, improving detection efficiency and reducing costs" (Alazba et al. Section 2, last paragraph).
Regarding Claim 18,
Brunel et al. in view of Deeptimahanti et al. in view of Savary-Leblanc et al. and further in view of Alazba et al. teaches the computer program product of claim 17.
In addition, Brunel et al. further teaches wherein the program instructions further cause the computer to: send the XMI representation compatibility report, the UML model validation report, and the UML model rank report to a user via a client device ([0041]: "debugging and profiling of the execution of a UML model that has a realization in the action language can be performed … Profiling involves reporting on the computational cycles spent on evaluating model elements. The reports generated by profiling can be hierarchically structured and can provide, for example, insight as to where execution of a model may be optimized" teaches generating reports for the UML model based on the execution of the model. [0049]-[0050]: "The alternative embodiment of the present invention may also generate, optimize and validate the implementation code of a UML component that incorporates the numerical and temporal behavior of the model ... the graphical programming or modeling environment may simulate a UML deployment diagram that enables a user to assess performance, load, reliability, and schedulability requirements of the run-time processing nodes against the time and numerical resolution of control and signal-processing algorithms with safety and reliability constraints" teaches validating the UML model corresponding to the architecture solution and that a user is provided reports about the UML model (e.g. the user is sent the XMI representation compatibility report, the UML model validation report, and the UML model rank report). Fig. 3; [0075]-[0078]: "the client 26 may include a UML modeling environment 4 that enables a user to build a UML model ... The client 27 may include the graphical programming or modeling environment 8 that enables a user to build and simulate/execute a block diagram model" teaches that the user is sent the UML model reports via a client device); and
implement the architecture solution in an environment corresponding to the user in response to receiving an input from the user to implement the architecture solution based on the XMI representation compatibility report, the UML model validation report, and the UML model rank report ([0041]: "debugging and profiling of the execution of a UML model that has a realization in the action language can be performed … Profiling involves reporting on the computational cycles spent on evaluating model elements. The reports generated by profiling can be hierarchically structured and can provide, for example, insight as to where execution of a model may be optimized" teaches generating reports for the UML model based on the execution of the model. [0049]-[0050]: "The alternative embodiment of the present invention may also generate, optimize and validate the implementation code of a UML component that incorporates the numerical and temporal behavior of the model ... the graphical programming or modeling environment may simulate a UML deployment diagram that enables a user to assess performance, load, reliability, and schedulability requirements of the run-time processing nodes against the time and numerical resolution of control and signal-processing algorithms with safety and reliability constraints" teaches validating the UML model corresponding to the architecture solution and that a user is provided reports about the UML model (e.g. the user is sent the XMI representation compatibility report, the UML model validation report, and the UML model rank report). [0058]-[0059]: "a graphical programming or modeling environment enables a user to graphically program the behavior of a Unified Modeling Language (UML) model. The graphical programming or modeling environment represents a software or hardware system as a collection of blocks interconnected by lines. Blocks are entities of the system that perform given functions in the system ... a UML model may be exported into a text-based format, such as the XML Metadata Interface (XMI) format. The graphical programming or modeling environment may import the UML model and represent the UML model using behavioral blocks provided in the graphical programming or modeling environment. The illustrative embodiment may provide a publishing tool for representing the components of the UML model using hierarchical functional blocks in the graphical programming or modeling environment. The graphical programming or modeling environment enables a user or programmer to graphically define the behaviors of the UML model so that the UML model can be executed. The UML model can be modified based on the execution results" teaches that the UML model architecture solution is implemented in an environment corresponding to the user in response to user input based on the execution reports of the UML model).
Conclusion
Any inquiry concerning this communication or earlier communications from the examiner should be directed to BRIAN J HALES whose telephone number is (571)272-0878. The examiner can normally be reached M-F 9:00am - 5:00pm.
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, Kamran Afshar can be reached at (571) 272-7796. 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.
/BRIAN J HALES/Examiner, Art Unit 2125
/KAMRAN AFSHAR/Supervisory Patent Examiner, Art Unit 2125
