CN116243893A - Low code output method - Google Patents
Low code output method Download PDFInfo
- Publication number
- CN116243893A CN116243893A CN202310049881.5A CN202310049881A CN116243893A CN 116243893 A CN116243893 A CN 116243893A CN 202310049881 A CN202310049881 A CN 202310049881A CN 116243893 A CN116243893 A CN 116243893A
- Authority
- CN
- China
- Prior art keywords
- engineering
- code
- page
- file
- description file
- Prior art date
- Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
- Pending
Links
- 238000000034 method Methods 0.000 title claims abstract description 31
- 238000011161 development Methods 0.000 claims abstract description 19
- 238000005457 optimization Methods 0.000 claims abstract description 7
- 230000001419 dependent effect Effects 0.000 claims description 15
- 238000013507 mapping Methods 0.000 claims description 9
- 238000004806 packaging method and process Methods 0.000 claims description 4
- 238000009434 installation Methods 0.000 claims description 3
- 238000013461 design Methods 0.000 description 6
- 238000013499 data model Methods 0.000 description 3
- 230000008569 process Effects 0.000 description 3
- 230000009466 transformation Effects 0.000 description 3
- 238000010586 diagram Methods 0.000 description 2
- 238000012827 research and development Methods 0.000 description 2
- 230000006978 adaptation Effects 0.000 description 1
- 238000013473 artificial intelligence Methods 0.000 description 1
- 230000004888 barrier function Effects 0.000 description 1
- 230000008878 coupling Effects 0.000 description 1
- 238000010168 coupling process Methods 0.000 description 1
- 238000005859 coupling reaction Methods 0.000 description 1
- 238000005516 engineering process Methods 0.000 description 1
- 238000012986 modification Methods 0.000 description 1
- 230000004048 modification Effects 0.000 description 1
- 230000009467 reduction Effects 0.000 description 1
- 230000004044 response Effects 0.000 description 1
- 239000007858 starting material Substances 0.000 description 1
- 230000003068 static effect Effects 0.000 description 1
- 230000000007 visual effect Effects 0.000 description 1
Images
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F8/00—Arrangements for software engineering
- G06F8/20—Software design
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F8/00—Arrangements for software engineering
- G06F8/30—Creation or generation of source code
- G06F8/34—Graphical or visual programming
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F8/00—Arrangements for software engineering
- G06F8/40—Transformation of program code
- G06F8/41—Compilation
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F8/00—Arrangements for software engineering
- G06F8/40—Transformation of program code
- G06F8/41—Compilation
- G06F8/42—Syntactic analysis
- G06F8/427—Parsing
-
- Y—GENERAL TAGGING OF NEW TECHNOLOGICAL DEVELOPMENTS; GENERAL TAGGING OF CROSS-SECTIONAL TECHNOLOGIES SPANNING OVER SEVERAL SECTIONS OF THE IPC; TECHNICAL SUBJECTS COVERED BY FORMER USPC CROSS-REFERENCE ART COLLECTIONS [XRACs] AND DIGESTS
- Y02—TECHNOLOGIES OR APPLICATIONS FOR MITIGATION OR ADAPTATION AGAINST CLIMATE CHANGE
- Y02D—CLIMATE CHANGE MITIGATION TECHNOLOGIES IN INFORMATION AND COMMUNICATION TECHNOLOGIES [ICT], I.E. INFORMATION AND COMMUNICATION TECHNOLOGIES AIMING AT THE REDUCTION OF THEIR OWN ENERGY USE
- Y02D10/00—Energy efficient computing, e.g. low power processors, power management or thermal management
Landscapes
- Engineering & Computer Science (AREA)
- General Engineering & Computer Science (AREA)
- Theoretical Computer Science (AREA)
- Software Systems (AREA)
- Physics & Mathematics (AREA)
- General Physics & Mathematics (AREA)
- Stored Programmes (AREA)
Abstract
The invention provides a low-code output method in the technical field of low-code application development, which comprises the following steps: s10, analyzing the DSL resource package to obtain engineering configuration information, engineering configuration items, an engineering dependency library, an engineering page list, a page route and a global style, and further generating a code description file; step S20, de-duplication is carried out on the code-out description file, and dynamic optimization is carried out on the code-out description file; step S30, creating an engineering template, converting the code-out description file into engineering codes by using the engineering template, and storing the engineering codes into the created temporary catalogue; step S40, dynamically optimizing engineering codes stored in the temporary catalogue; and S50, compiling the engineering code to generate an executable packet. The invention has the advantages that: the expansibility, flexibility and compatibility of low-code application development are greatly improved, and the low-code application performance is greatly improved.
Description
Technical Field
The invention relates to the technical field of low-code application development, in particular to a low-code outputting method.
Background
With the continuous development and application of new IT technologies such as big data, internet of things, 5G, cloud computing, artificial intelligence and the like, powerful guarantee is provided for enterprise digital transformation in the aspects of business architecture optimization, value upgrading and the like, enterprise core competitiveness is enhanced, enterprise business modes are innovated, and enterprise business is rapidly expanded and market opportunities are won. Under the rapid development of digital economy and the background of sudden epidemic situation in recent years, the digital demands of enterprises become more and more mixed, and the demands of customization degree and quick response capability become higher and higher. How to maximize and utilize the technical innovation, break the barrier between business and research and development, improve the research and development efficiency of business application, thus promote the business model innovation, is the strategic core of the digitized transformation of enterprises.
The Low-Code development provides flexible, intelligent and powerful visual and graphic design capability, new experience is built and developed by dragging, and enterprise digital assets can be effectively deposited based on the Low-Code platformization, so that the enterprise is assisted in cost reduction and synergy, the business innovation and intelligent upgrading of the enterprise are realized, and the Low-Code development is an 'accelerator' for enterprise digital transformation.
Traditional low code application development includes at least four steps: data model design, page design, DSL resource package generation and application release deployment. The method comprises the steps of developing a low-code application, firstly designing a data model of entity, data, enumeration and the like, carrying out page design through dragging components, packaging the designed data model and the page to generate a DSL resource package, and finally publishing and deploying the DSL resource package through a deployment tool to deliver the DSL resource package for use by a user.
A conventional low code application generates a DSL resource packet for describing a page of the low code application and resources used by the application, where the DSL resource packet is an "interpreted" packet that can be identified only when the application is running, and requires a page that can be run and rendered only when the application is running, resulting in the following problems: 1. depending on the runtime application: the low-code application must be run on a specific running application, is not easy to expand and has poor flexibility; 2. the performance is poor: the DSL needs to be analyzed in the running process, then the DSL needs to be rendered in real time, the page presentation is long in time consumption, and the performance of the page with special complexity is relatively poor; 3. incompatible old items: the application releases a complete package, and the low code development is not well accessed in the mode of old project and new demand.
Therefore, how to provide a low-code output method, to improve the expansibility, flexibility and compatibility of low-code application development, and to improve the low-code application performance, is a technical problem to be solved urgently.
Disclosure of Invention
The invention aims to solve the technical problem of providing a low-code output method, which can improve the expansibility, flexibility and compatibility of low-code application development and improve the low-code application performance.
The invention is realized in the following way: a low code output method, comprising the steps of:
s10, analyzing the DSL resource package to obtain engineering configuration information, engineering configuration items, an engineering dependency library, an engineering page list, a page route and a global style, and further generating a code description file;
step S20, de-duplication is carried out on the code-out description file, and dynamic optimization is carried out on the code-out description file;
step S30, creating an engineering template, converting the code-out description file into engineering codes by using the engineering template, and storing the engineering codes into the created temporary catalogue;
step S40, dynamically optimizing engineering codes stored in the temporary catalogue;
and S50, compiling the engineering code to generate an executable packet.
Further, the step S10 specifically includes:
analyzing DSL resource package to obtain engineering configuration information at least including engineering name and engineering version, at least including theme color and engineering configuration item of engineering development frame, at least including engineering dependency library of dependent component and component version, at least including page component dependency item, component tree, component attribute, component event, page reference variable, page reference function, page life cycle function, page reference data source, page style, occupation component description and page description information, at least including page and route path mapping and page route of nested relation of page and route, at least including pattern type and global pattern of pattern content;
and generating an output code description file based on the engineering configuration information, the engineering configuration items, the engineering dependency library, the engineering page list, the page route and the global style.
Further, the step S20 specifically includes:
traversing the page list of the code-out description file, acquiring all data sources referenced by pages, de-duplicating the data sources based on the ID of the data sources, and further dynamically optimizing the code-out description file.
Further, the step S30 specifically includes:
step S31, creating an engineering template and a temporary catalogue, and decompressing the engineering template to the temporary catalogue;
step S32, extracting page component dependent items from the code-out description file, dynamically filling the page component dependent items according to tdesignackage. Json specifications to generate package. Json, and adding the package. Json to a temporary directory;
extracting a data source referenced by a page from the code-out description file, generating an API file comprising a data source method name and a reference-in and data source method exposing based on the data source, and adding the API file to a temporary directory;
extracting page description information from the code-out description file, and splicing a component tree, a component attribute and a component event according to an html grammar based on the page description information to generate a template node; importing page component dependent items, page reference variables, page reference functions and page lifecycle functions based on the page description information to generate script nodes; splicing the style types and style contents according to the html form based on the page description information to generate style nodes; obtaining page codes based on the template node, the script node and the style node, and adding the page codes to a temporary directory;
extracting path mapping of pages and routes and nesting relation of the pages and the routes from the code-out description file, generating a json-format route file based on the path mapping and the nesting relation for exposure, and adding the route file to a router folder of a temporary directory;
extracting a theme color from the code-out description file, updating a style.ts file based on the theme color, and adding the style.ts file to a config folder of a temporary directory;
and extracting engineering configuration information from the code-out description file, writing the engineering configuration information into an lc.worspace.json file, and adding the lc.worspace.json file into a temporary directory.
Further, the step S40 specifically includes:
and traversing the temporary catalogue, correcting and beautifying the engineering codes under the temporary catalogue by using a line plug-in, deleting unused variables in the engineering codes based on line number position information so as to dynamically optimize the engineering codes, and re-outputting the optimized engineering codes to the temporary catalogue.
Further, the step S50 specifically includes:
and executing the installation dependent command under the temporary directory, executing the packaging command to generate a dist directory, and compressing the dist directory into an executable package in a zip format.
The invention has the advantages that:
acquiring engineering configuration information, an engineering dependency library, an engineering page list, a page route and a global style by analyzing DSL resource packages of low-code application to generate an outgoing code description file, de-duplicating a data source referenced by a page in the outgoing code description file, converting the outgoing code description file into engineering codes by using a created engineering template, correcting and beautifying the engineering codes by using a link plug-in, deleting unused variables in the engineering codes, and compiling the engineering codes to generate an executable package; namely, DSL resource packages are converted into code-out description files and dynamically optimized, so that standardized generation of engineering codes is facilitated, and the engineering code generation module and the DSL resource packages are decoupled, so that the engineering code generation module is supported to adapt to different DSL resource packages, meanwhile, the code-out description files are dynamically optimized, the data of the code-out description files are more complete, different DSL resource packages are adapted, and the application range is expanded; by correcting and beautifying the engineering code and deleting unused variables, the engineering code has stronger readability, richer functions and more reliable performance; by generating the lc.work space.json file, the engineering description file contains the engineering name, engineering version and other metadata information, the engineering codes can be more conveniently maintained secondarily through the metadata information, and meanwhile, real-time synchronization with the design state of the low-code application can be achieved by combining a command line tool, so that the expansibility, flexibility and compatibility of low-code application development are improved greatly, and the low-code application performance is improved greatly.
Drawings
The invention will be further described with reference to examples of embodiments with reference to the accompanying drawings.
FIG. 1 is a flow chart of a low code output method of the present invention.
FIG. 2 is a flow chart of a low code output method according to the present invention.
FIG. 3 is a schematic diagram of the present invention for generating engineering code.
FIG. 4 is a schematic diagram of the present invention for generating page code.
Detailed Description
According to the technical scheme in the embodiment of the application, the overall thought is as follows: converting the DSL resource package into a code-out description file and dynamically optimizing the code-out description file, facilitating standardized generation of engineering codes, decoupling the engineering code generation module and the DSL resource package, supporting adaptation of different DSL resource packages, dynamically optimizing the code-out description file, enabling the code-out description file to be more complete in data, adapting to different DSL resource packages, and expanding the application range; by correcting and beautifying the engineering code and deleting unused variables, the engineering code has stronger readability, richer functions and more reliable performance; by generating the lc.work space.json file, the engineering description file contains the engineering name, engineering version and other metadata information, and the engineering code can be more conveniently maintained secondarily through the metadata information, so that the expansibility, flexibility and compatibility of low-code application development are improved, and the low-code application performance is improved.
Referring to fig. 1 to 4, a preferred embodiment of a low-code output method of the present invention includes the following steps:
s10, analyzing DSL resource packages of low-code application to obtain engineering configuration information, engineering configuration items, an engineering dependency library, an engineering page list, a page route and a global style, and further generating a code description file; analyzing and optimizing the DSL resource package to generate an engineering code when the code is output;
analyzing the DSL resource package to generate a code-out description file, namely analyzing the DSL resource package into standardized structured data which accords with code-out specifications, directly using the structured data in the process of generating engineering codes subsequently, avoiding secondary analysis of the DSL resource package, and reducing the coupling of the DSL resource package and the code-out;
step S20, de-duplication is carried out on the code-out description file, and dynamic optimization is carried out on the code-out description file;
since the same data source may be cited between pages, redundancy of the data source may be caused, and in order to avoid this problem, the duplication of the outbound description file needs to be removed;
step S30, creating an engineering template, converting the code-out description file into engineering codes by using the engineering template, and storing the engineering codes into the created temporary catalogue;
the core of generating the engineering code is to decompose an engineering project into two parts, namely engineering static and unchangeable file contents (such as pictures, basic framework files and the like) and dynamic changeable contents (such as api, style, pages and the like);
step S40, dynamically optimizing engineering codes stored in the temporary catalogue; the code-out description file and the engineering code are dynamically optimized, so that the low-code application is lighter, and the code-level performance is optimized;
and S50, compiling the engineering codes to generate executable packages, and supporting the mixed development of new and old projects without depending on the application in the running process, wherein the development of high codes and low codes are mutually fused.
Firstly analyzing DSL resource package to generate code-out description file, dynamically optimizing the code-out description file, then generating engineering code based on the code-out description file, performing secondary optimization on the engineering code, and finally compiling the generated engineering code into executable package; based on the optimization measures, the method realizes accurate tuning of low-code application performance, is compatible with old projects, removes dependence on runtime application, and is more flexible and has strong expandability.
The step S10 specifically includes:
analyzing DSL resource package to obtain engineering configuration information at least including engineering name and engineering version, at least including theme color and engineering configuration item of engineering development frame, at least including engineering dependency library of dependent component and component version, at least including page component dependency item, component tree, component attribute, component event, page reference variable, page reference function, page life cycle function, page reference data source, page style, occupation component description and page description information, at least including page and route path mapping and page route of nested relation of page and route, at least including pattern type and global pattern of pattern content;
and generating an output code description file based on the engineering configuration information, the engineering configuration items, the engineering dependency library, the engineering page list, the page route and the global style.
The step S20 specifically includes:
traversing the page list of the code-out description file, acquiring all data sources referenced by pages, de-duplicating the data sources based on the ID of the data sources, and further dynamically optimizing the code-out description file.
The step S30 specifically includes:
step S31, creating an engineering template and a temporary catalogue, and decompressing the engineering template to the temporary catalogue;
the engineering template is created based on tdesignstarters, firstly, a project initializing tool npmitdiestign-starter-cli-g is installed through a command line, then a command initializing project td-starter is executed to generate an initializing project, then a package.json file, a router folder, an api folder, pages folder and a style.ts file are removed, and finally project engineering is compressed into a zip package to be used as the engineering template;
step S32, extracting page component dependent items from the code-out description file, dynamically filling the page component dependent items according to tdesignackage. Json specifications to generate package. Json, and adding the package. Json to a temporary directory;
extracting a data source referenced by a page from the code-out description file, generating an API file comprising a data source method name and a reference-in and data source method exposing based on the data source, and adding the API file to a temporary directory;
extracting page description information from the code-out description file, and splicing a component tree, a component attribute and a component event according to an html grammar based on the page description information to generate a template node; importing page component dependent items, page reference variables, page reference functions and page lifecycle functions based on the page description information to generate script nodes; splicing the style types and style contents according to the html form based on the page description information to generate style nodes; obtaining page codes based on the template node, the script node and the style node, and adding the page codes to a temporary directory;
extracting path mapping of pages and routes and nesting relation of the pages and the routes from the code-out description file, generating a json-format route file based on the path mapping and the nesting relation for exposure, and adding the route file to a router folder of a temporary directory;
extracting a theme color from the code-out description file, updating a style.ts file based on the theme color, and adding the style.ts file to a config folder of a temporary directory;
and extracting engineering configuration information from the code-out description file, writing the engineering configuration information into an lc.worspace.json file, and adding the lc.worspace.json file (engineering description file) to a temporary directory.
The step S40 specifically includes:
and traversing the temporary catalogue, correcting and beautifying the engineering codes under the temporary catalogue by using a line plug-in, deleting unused variables in the engineering codes based on line number position information so as to dynamically optimize the engineering codes, and re-outputting the optimized engineering codes to the temporary catalogue.
The step S50 specifically includes:
and executing an installation dependent command (pnp minstall) under the temporary directory, and then executing a packaging command (pnp mrun build) to generate a dist directory, and compressing the dist directory into executable packages in a zip format.
The low-code application constructed based on the method is independent of the runtime application, so that the volume of the low-code application is reduced by 50%, the generation of engineering codes (source codes) is supported, the code-level performance can be optimized through optimizing the engineering codes, and compared with the traditional method, the page opening speed is improved by 31%, and the method can be used for fusing and developing the application with the old projects to be suitable for a wider scene.
In summary, the invention has the advantages that:
acquiring engineering configuration information, an engineering dependency library, an engineering page list, a page route and a global style by analyzing DSL resource packages of low-code application to generate an outgoing code description file, de-duplicating a data source referenced by a page in the outgoing code description file, converting the outgoing code description file into engineering codes by using a created engineering template, correcting and beautifying the engineering codes by using a link plug-in, deleting unused variables in the engineering codes, and compiling the engineering codes to generate an executable package; namely, DSL resource packages are converted into code-out description files and dynamically optimized, so that standardized generation of engineering codes is facilitated, and the engineering code generation module and the DSL resource packages are decoupled, so that the engineering code generation module is supported to adapt to different DSL resource packages, meanwhile, the code-out description files are dynamically optimized, the data of the code-out description files are more complete, different DSL resource packages are adapted, and the application range is expanded; by correcting and beautifying the engineering code and deleting unused variables, the engineering code has stronger readability, richer functions and more reliable performance; by generating the lc.work space.json file, the engineering description file contains the engineering name, engineering version and other metadata information, the engineering codes can be more conveniently maintained secondarily through the metadata information, and meanwhile, real-time synchronization with the design state of the low-code application can be achieved by combining a command line tool, so that the expansibility, flexibility and compatibility of low-code application development are improved greatly, and the low-code application performance is improved greatly.
While specific embodiments of the invention have been described above, it will be appreciated by those skilled in the art that the specific embodiments described are illustrative only and not intended to limit the scope of the invention, and that equivalent modifications and variations of the invention in light of the spirit of the invention will be covered by the claims of the present invention.
Claims (6)
1. A low code output method is characterized in that: the method comprises the following steps:
s10, analyzing the DSL resource package to obtain engineering configuration information, engineering configuration items, an engineering dependency library, an engineering page list, a page route and a global style, and further generating a code description file;
step S20, de-duplication is carried out on the code-out description file, and dynamic optimization is carried out on the code-out description file;
step S30, creating an engineering template, converting the code-out description file into engineering codes by using the engineering template, and storing the engineering codes into the created temporary catalogue;
step S40, dynamically optimizing engineering codes stored in the temporary catalogue;
and S50, compiling the engineering code to generate an executable packet.
2. A low code escape method as defined in claim 1, wherein: the step S10 specifically includes:
analyzing DSL resource package to obtain engineering configuration information at least including engineering name and engineering version, at least including theme color and engineering configuration item of engineering development frame, at least including engineering dependency library of dependent component and component version, at least including page component dependency item, component tree, component attribute, component event, page reference variable, page reference function, page life cycle function, page reference data source, page style, occupation component description and page description information, at least including page and route path mapping and page route of nested relation of page and route, at least including pattern type and global pattern of pattern content;
and generating an output code description file based on the engineering configuration information, the engineering configuration items, the engineering dependency library, the engineering page list, the page route and the global style.
3. A low code escape method as defined in claim 1, wherein: the step S20 specifically includes:
traversing the page list of the code-out description file, acquiring all data sources referenced by pages, de-duplicating the data sources based on the ID of the data sources, and further dynamically optimizing the code-out description file.
4. A low code escape method as defined in claim 1, wherein: the step S30 specifically includes:
step S31, creating an engineering template and a temporary catalogue, and decompressing the engineering template to the temporary catalogue;
step S32, extracting page component dependent items from the code-out description file, dynamically filling the page component dependent items according to tdesign package/json specifications to generate package/json, and adding the package/json to a temporary directory;
extracting a data source referenced by a page from the code-out description file, generating an API file comprising a data source method name and a reference-in and data source method exposing based on the data source, and adding the API file to a temporary directory;
extracting page description information from the code-out description file, and splicing a component tree, a component attribute and a component event according to an html grammar based on the page description information to generate a template node; importing page component dependent items, page reference variables, page reference functions and page lifecycle functions based on the page description information to generate script nodes; splicing the style types and style contents according to html css forms based on the page description information to generate style nodes; obtaining page codes based on the template node, the script node and the style node, and adding the page codes to a temporary directory;
extracting path mapping of pages and routes and nesting relation of the pages and the routes from the code-out description file, generating a json-format route file based on the path mapping and the nesting relation for exposure, and adding the route file to a router folder of a temporary directory;
extracting a theme color from the code-out description file, updating a style.ts file based on the theme color, and adding the style.ts file to a config folder of a temporary directory;
and extracting engineering configuration information from the code-out description file, writing the engineering configuration information into an lc.worspace.json file, and adding the lc.worspace.json file into a temporary directory.
5. A low code escape method as defined in claim 1, wherein: the step S40 specifically includes:
and traversing the temporary catalogue, correcting and beautifying the engineering codes under the temporary catalogue by using a line plug-in, deleting unused variables in the engineering codes based on line number position information so as to dynamically optimize the engineering codes, and re-outputting the optimized engineering codes to the temporary catalogue.
6. A low code escape method as defined in claim 1, wherein: the step S50 specifically includes:
and executing the installation dependent command under the temporary directory, executing the packaging command to generate a dist directory, and compressing the dist directory into an executable package in a zip format.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202310049881.5A CN116243893A (en) | 2023-02-01 | 2023-02-01 | Low code output method |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202310049881.5A CN116243893A (en) | 2023-02-01 | 2023-02-01 | Low code output method |
Publications (1)
| Publication Number | Publication Date |
|---|---|
| CN116243893A true CN116243893A (en) | 2023-06-09 |
Family
ID=86625450
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN202310049881.5A Pending CN116243893A (en) | 2023-02-01 | 2023-02-01 | Low code output method |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN116243893A (en) |
-
2023
- 2023-02-01 CN CN202310049881.5A patent/CN116243893A/en active Pending
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| CN111666526B (en) | Page generation method, device, equipment and storage medium | |
| Kolovos et al. | The epsilon object language (EOL) | |
| US8826225B2 (en) | Model transformation unit | |
| CN101334728B (en) | Interface creating method and platform based on XML document description | |
| CN101777004B (en) | Method and system for realizing BPEL sub-process multiplexing based on template in service-oriented environment | |
| US20070079299A1 (en) | Method, apparatus and program storage device for representing eclipse modeling framework (EMF) ecore models in textual form | |
| EP1576439A2 (en) | A method, a language and a system for the definition and implementation of software solutions | |
| JP5567682B2 (en) | Normalized version of reuse candidates in graphical state transition diagram model | |
| JP6479184B2 (en) | Computer-executable model reverse engineering method and apparatus | |
| JP2007179165A (en) | Computer program and method for deriving stochastic performance evaluation model from ulm design model | |
| WO2017033441A1 (en) | System construction assistance system and method, and storage medium | |
| CN111880777A (en) | Program information issuing method and device and electronic equipment | |
| CN113553035A (en) | Design and construction method of universal front-end UI component library | |
| JP3562435B2 (en) | Automatic component generator | |
| CN114721711B (en) | Tool and method for reducing software research and development configuration based on GraphQL | |
| CN116243893A (en) | Low code output method | |
| US20070236369A1 (en) | Configurable importers and resource writers | |
| CN113778421A (en) | Method and equipment for generating service code | |
| JP7059757B2 (en) | API processing method, terminal, API processing program | |
| Sabraoui et al. | Metamodel extension approach applied to the model-driven development of mobile applications | |
| JPH07129382A (en) | Spiral type object oriented software development supporting system and software developing method | |
| JP4154164B2 (en) | Knowledge reuse system | |
| US20230289151A1 (en) | Generation and consumption of templates based on source code examples | |
| Rossi et al. | Model-based design of volatile functionality in Web applications | |
| Madari et al. | Traceability-based incremental model synchronization |
Legal Events
| Date | Code | Title | Description |
|---|---|---|---|
| PB01 | Publication | ||
| PB01 | Publication | ||
| SE01 | Entry into force of request for substantive examination | ||
| SE01 | Entry into force of request for substantive examination |