CN109976747B - Visual development implementation system of module-level code structure - Google Patents
Visual development implementation system of module-level code structure Download PDFInfo
- Publication number
- CN109976747B CN109976747B CN201910104818.0A CN201910104818A CN109976747B CN 109976747 B CN109976747 B CN 109976747B CN 201910104818 A CN201910104818 A CN 201910104818A CN 109976747 B CN109976747 B CN 109976747B
- Authority
- CN
- China
- Prior art keywords
- module
- code
- layer
- splicing
- interface
- 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.)
- Expired - Fee Related
Links
- 230000000007 visual effect Effects 0.000 title claims abstract description 36
- 238000011161 development Methods 0.000 title claims abstract description 34
- 238000012800 visualization Methods 0.000 claims abstract description 24
- 230000006870 function Effects 0.000 claims description 25
- 239000000463 material Substances 0.000 claims description 14
- 230000005540 biological transmission Effects 0.000 claims description 12
- 238000012546 transfer Methods 0.000 claims description 11
- 238000013507 mapping Methods 0.000 claims description 6
- 238000000034 method Methods 0.000 description 20
- 238000013461 design Methods 0.000 description 6
- 238000012545 processing Methods 0.000 description 5
- 230000008569 process Effects 0.000 description 3
- 238000010586 diagram Methods 0.000 description 2
- 210000001503 joint Anatomy 0.000 description 2
- 241001289753 Graphium sarpedon Species 0.000 description 1
- 101001094044 Mus musculus Solute carrier family 26 member 6 Proteins 0.000 description 1
- 230000006978 adaptation Effects 0.000 description 1
- 230000002776 aggregation Effects 0.000 description 1
- 238000004220 aggregation Methods 0.000 description 1
- 238000013459 approach Methods 0.000 description 1
- 230000009286 beneficial effect Effects 0.000 description 1
- 238000006243 chemical reaction Methods 0.000 description 1
- 238000010276 construction Methods 0.000 description 1
- 230000000694 effects Effects 0.000 description 1
- 238000005516 engineering process Methods 0.000 description 1
- 230000008676 import Effects 0.000 description 1
- 238000007373 indentation Methods 0.000 description 1
- 238000013508 migration Methods 0.000 description 1
- 230000005012 migration Effects 0.000 description 1
- 230000008520 organization Effects 0.000 description 1
- 238000003672 processing method Methods 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/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/30—Creation or generation of source code
- G06F8/36—Software reuse
Landscapes
- Engineering & Computer Science (AREA)
- Software Systems (AREA)
- General Engineering & Computer Science (AREA)
- Theoretical Computer Science (AREA)
- Physics & Mathematics (AREA)
- General Physics & Mathematics (AREA)
- Stored Programmes (AREA)
Abstract
The invention discloses a visual development implementation system of a module-level code structure. The system of the invention comprises: a text code layer, a visualization layer, and a compiler of the programming language employed. The text code layer comprises a data set structure, a code module interface, a code module adapter or a buffer and a module splicing domain; the visualization layer comprises visualization elements of four structures, namely a data set structure, a code module interface, a code module adapter or buffer and a module splicing domain in the text code layer, wherein the visualization elements are two-dimensional graphs or three-dimensional models. The invention makes the code structure of program compiling and software developing clear, improves the code reuse rate, realizes the visual development of module-level software or program, enables non-computer professionals to use the developed code module to complete the development through simple operation, and reduces the software development threshold.
Description
Technical Field
The invention relates to the field of code compiling and software development, in particular to a modular visual development system formed by a modular development code structure and a module-level visual development method.
Background
With the increasing complexity and demand of software, enterprises and developers are more concerned about the rapid construction and code reuse of software engineering. On one hand, software with high complexity needs a programming method capable of clearly describing the relationship between a software architecture and a functional board so as to improve the reusability and maintainability of software development; on the other hand, the popularization of the internet and the internet of things causes more non-computer professionals to have programming requirements, but the programming level is limited by the programming level, and the whole development cannot be completed independently, so that a programming method capable of carrying out simplified development by using the developed code resources in the field is also needed.
From the perspective of programming language and programming method, the current programming method is process-oriented and object-oriented, the highest structure level of the process-oriented is a function level, the highest structure level of the object-oriented is an object level, the relevance between the process-oriented programming variable and the function is weak, and the code reuse difficulty is high; although the code reuse rate of the object-oriented programming is obviously high, the relationship among the objects is complex, so that the constructed object relationship graph is too complex to support visual programming.
From the perspective of visual programming technology, visual programming is mainly realized by visually abstracting statements, functions and variables at present, visual elements correspond to one of the statements, the visual elements are low in code reuse rate and development efficiency, and the visual elements are mainly applied to children programming enlightenment and cannot be applied to actual generation.
Disclosure of Invention
In order to solve the problems in the related art, the embodiment of the invention provides a visualized development implementation system of a module-level code structure.
A visual development implementation system of a module-level code structure comprises three layers of structures: the system comprises a text code layer, a file management layer and a code expression layer, wherein the text code layer is used for writing an operation sequence, an operation and a data structure of a code expression program through traditional characters and storing the operation sequence, the operation and the data structure in the file; the visual development layer is a code structure which represents an operation sequence, an operation and a data structure in a graphic image mode, and expresses the execution sequence, the data transmission direction and the structure of the whole program according to the position relation and the splicing direction of the three; and thirdly, compiling the final source code of the text code layer into an executable file by using a compiler of the adopted programming language. Specifically, the method comprises the following steps:
the text code layer comprises a data set structure, a code module interface, a code module adapter or a buffer and a module splicing domain; the visualization development layer comprises visualization elements corresponding to four structures, namely a data set structure, a code module interface, a code module adapter or a buffer and a module splicing domain in the text code layer, wherein the visualization elements are two-dimensional graphs or three-dimensional models.
The text code layer adopts any object-oriented programming language, constructs a functional module, a module interface, a module adapter and a module splicing domain on a language class and a code structure of an object, defines and writes code materials in a text mode and assembles the materials into a complete program or software by splicing sentences in the splicing domain, wherein the code materials comprise variables, functions, classes, functional modules, module interfaces, module adapters and data sets.
Functional module, its inner structure includes: the system comprises a material library reference declaration area, a global variable declaration and definition area, a mode definition area, an interface definition area, a working code area, a function, a class definition and implementation area; the mode definition area contains one or more module mode definitions, and the module mode controls the function realization of the module by controlling whether the statement in the module executes or not and whether the interface is enabled or not.
The code module interface is used for describing a mode of data transmission variables and a transfer direction of the variable values when the modules are spliced, wherein the transfer mode comprises value transfer and depth transfer, and the transfer direction comprises transmission in and transmission out.
The code module adapter is used for receiving variables output in the interfaces of the two parties or the multiple parties, carrying out programming operation processing on the variables, and determining whether to output, what type to output and what value to output so as to eliminate mismatching of data quantity, data type and data sequence in the interfaces of the modules.
The module splicing domain comprises an external reference statement region, a global top variable statement and definition region, an intra-domain work code region (Workspace) and a domain-level material definition region, and modules are spliced vertically (sequentially executed) and horizontally (parallelly executed) in the work region by using a splicing statement.
The visual development layer encapsulates the code structure into a two-dimensional plane graph, takes the two-dimensional plane graph as a visual material, and splices the two-dimensional plane graph into a required program through dragging and splicing operations to complete development.
The mapping between the visual development layer and the code layer is as follows: and translating the code module, the data set, the code module interface and the code module adapter into a text code in the module splicing domain, wherein the code module, the data set, the code module interface and the code module adapter correspond to the two-dimensional plane graph one by one, declaring in the module splicing domain, and translating the vertical and horizontal splicing relation of the elements of the visual development layer and the transmission relation of the data set, the code module interface and the code module adapter into the text code in the module splicing domain.
The using method of the invention comprises the following steps:
directly developing software in a text code layer according to the design;
secondly, on a visual code layer, visual elements form a whole through dragging, splicing and configuration operations to complete software development, and finally a visual compiling system translates the content of the visual layer into text codes according to the mapping relation between the visual elements and the structure of the text code layer and the operation of developers. The system realizes high aggregation of program functions in the code modules through a brand-new code structure design, combines object-oriented programming and process-oriented programming in a software engineering theory, adopts object-oriented programming in a structure below the modules, adopts process-oriented programming in a structure above the modules, preliminarily ensures code reuse rate and software development convenience by the object-oriented programming, emphasizes the organization of the code structure by the process-oriented programming and further improves the code reuse rate.
The invention has the following beneficial effects:
the method has the advantages that the code structure of program compiling and software development is clear, the code reuse rate is improved, module-level software or program visual development is realized, non-computer professionals can use the developed code module to complete development through simple operation, and the software development threshold is reduced.
Drawings
In order to more clearly illustrate the technical solutions in the embodiments of the present invention, the drawings required to be used in the description of the embodiments will be briefly introduced below, and it is apparent that the drawings in the following description are only one embodiment of the present invention, and other implementation approaches can be designed for a programming language and a compiler designer to perform migration variants.
FIG. 1 is a diagram of a visualization development layer and text code layer mapping relationship using the system of the present invention.
FIG. 2 is a diagram of the effects of software usage developed based on the visualization of the implementation using the system of the present invention.
FIG. 3 is a flow chart of the generation of the system of the present invention from the visualization development layer to the final executable file.
Detailed Description
In order to make the objects, technical solutions and advantages of the present invention more apparent, embodiments of the present invention will be described in detail with reference to the accompanying drawings.
In order to facilitate understanding of the technical solutions provided by the embodiments of the present invention, a code structure of a text layer will be described below by taking a programming language designed according to the method of the present invention as an example.
As shown in FIG. 1, the text code layer comprises a dataset structure, a code module interface, a code module adapter or buffer, and a module splicing domain; the visualization development layer comprises visualization elements corresponding to four structures, namely a data set structure, a code module interface, a code module adapter or a buffer and a module splicing domain in the text code layer, wherein the visualization elements are two-dimensional graphs or three-dimensional models.
Text code layer function module: is a highly functional aggregate code module, each module can accomplish one or more functions without relying on any code other than external dependencies within a reference declaration area, and the internal structure includes external application declarations, module interfaces, module schemas, work code areas, internal variable declarations, functions, and class definitions.
Data set: is a set of various types of variables with initial values arranged in sequence.
Module interface: the method is a matching slot of a data exchange channel during splicing between modules, and variable types, variable names, variable value transfer modes and variable directions are declared in the matching slot.
Code module adapter: the adapter is used for connecting unmatched (including data quantity, data type and data position) interfaces through processing, and the unmatched interfaces include declarations and definitions of new data and contain codes for performing operation processing on module interface data and new declarations or definition data in the adapter.
A module splicing domain: the module splicing domain is used for splicing the code modules to form new code modules or form the final top layer of the software, and allows the inlaying definition. The internal part of the system comprises an external reference declaration area, a global top-level variable declaration and definition area, an intra-domain work code area (Workspace) and a domain-level material (adapter, class, function and data set) definition area.
The visualization elements in the visualization layer in the module level visualization programming system mainly image the high-level code structure of the text code layer into a two-dimensional or three-dimensional graphic image, and comprise the following steps:
a start module: the first initial function module of the program is represented corresponding to the function module of the text code layer, and only one splicing domain is provided for convenient identification, so that the splicing domains are identified independently.
An end module: the functional modules corresponding to the functional modules of the text code layer represent the last executed functional modules of the program, and each splicing domain can be provided with a plurality of splicing domains, so that the splicing domains are identified independently for convenient identification.
Visual development layer function module: corresponding to the functional modules of the text code layer, all the functional modules except the starting module and the ending module are represented in the visualization layer and can be spliced with the starting module, the ending module, the module adapter, other functional modules and the data set.
Module interface: corresponding to the module interface of the text code layer, the visualization layer is represented as a channel connected between modules (comprising a starting module, an ending module and a function module).
A module adapter: corresponding to the module adapter of the text code layer, the visualization layer is mainly spliced with two (or more) modules simultaneously, and the way represents that the interface data processing spliced on one side is transmitted to the intra-module interface on the other side; the other is represented by simultaneous concatenation with the module and the data set, which means that the data of the data set is processed and transferred to the module on the other side.
Data set: corresponding to the data set of the text code layer, the visual representation is an element spliced with the module interface or the module adapter, and represents the transmission or assignment of values to the spliced element.
A module splicing domain: the module splicing domain of the text code layer corresponds to, a working space for splicing other visual elements is represented in the visual layer, and the working space corresponds to an entity file.
The text code layer function module code embodiment is as follows:
the code is a specific code module designed according to the method, and the keyword import guides an external dependency statement; the key word "pattern" indentation line content is the definition of the module mode label; the content guided under the keyword "interface" is the statement and definition of the interface, and each module can define a plurality of modules; the key word 'start-end' range is a code working area, when the module is started, statements in the range are sequentially executed, and the execution process is selectively executed according to the mode label; the final part is declarative definition of the internal functions and classes required by the module. The contents in the above modules can be default except the code working area of "start-end", and the representation forms of keywords and the like can be changed accordingly, so long as the functional design and code execution conditions of the module components (module interfaces and module modes) are the same as those described in the invention, and the invention is within the scope of the invention.
The data set is a series of ordered variable sets with initial values, and is a structural body in form, but emphasizes that each variable must have an initial value, and the sequence of the occurrence of the variables has meaning, and the variables can be identified by a compiler as information collection to be matched when an interface is imported, and the data set code is as follows:
the code module adapter is used for outputting data transmitted from the interface to the other interface to be transmitted by calculation conversion under the condition that two or more interfaces of the module are not matched, and ignoring the data if the data output from the interface is redundant. The code module adapter has three main functions, namely receiving data, processing data and transmitting data. Code module adaptation code embodiments are as follows:
in the above codes, the keyword "adapter" indicates that the adapter definition starts, "adapter name" is the adapter name, "the" is the interface processed by the adapter "inside," the following code is to process the unmatched data, "and" >: the indented content of the guide is the final data transmission. The design of the adapter is not limited to the type of programming language, the form of expression, and the writing format, and it is within the scope of the present invention that the content and the functional features conform to the contents of the present application.
The module splicing domain is the highest level code structure in the invention and is used for splicing the code modules to complete the required functions or form new code modules. The internal structure includes: an external reference declaration area, a global top-level variable declaration and definition area, a work code area (Workspace) within a domain, a domain-level material (adapter, class, function, dataset) definition area.
Specific code examples are as follows:
in the above embodiment code, what is guided within the range of the keyword "start-end" is that a conventional code statement (including an arithmetic statement and a control flow statement) and a module concatenation statement can be performed in a code work area, where "module _1< pat _1> (inter _1, inter _ 2)" statement four-module start statement, "module _ 1" is a module name, "< >" is a module mode label, "and" () "," | "guided statement is a data set transfer-in or an adapter use. The statements in the code working area are executed from top to bottom in sequence, similarly, the module splicing domain can not be limited by languages, expression modes and writing formats, and all functional designs meeting the required characteristics of the invention belong to the scope of the invention.
To illustrate the visualization layer to text code layer generation method, the method will be described in detail below with respect to the embodiment in fig. 2:
in the right working area of fig. 2, splicing is performed, wherein a blue triangle "start" module, which is a module in nature, functions to be started when the domain is started, and each domain can only be one; the red "end" module is similar to "start", but there may be more than one per domain; the purple square module is a common functional module; ink color "adapter _ 1" is the adapter; the yellow buffer _1 is a buffer module, and the buffer is derived from the adapter essentially, and has no difference from the adapter except that the buffer can store data and has a longer life cycle.
For this visualization development layer embodiment, the processing method and process are shown in FIG. 3. Each splicing domain generates an x, md file in the hard disk of the computer, and the file is a text code file of the splicing domain and the inside of the text code file is the code of a specific programming language.
When a visual element is dragged into a splicing region, a reference declaration is generated in the declaration region in the md according to the element file name and the storage path, except for a module, an adapter and a data set reference declaration, if other external resources such as classes, functions and the like are used by a programming language, the reference declaration generated by the implementation is as follows:
the above references do not refer to specific memory addresses, and the relevant file contents are automatically obtained from the set connection path by the compiler.
The creation of a new module or a related accessory is the writing of a text mode, and the invention only applies for the module and accessory internal implementation method and the macroscopic splicing mapping method.
After the modules are spliced, a user needs to set a butt joint interface of the two parties and a module starting mode, the two items of information are not reflected in a picture, the user selects and inputs the information, the system is internally recorded, if the two parties are in butt joint, a gray rectangle can appear between the two parties, a gray connection mark can not appear through connection of an adapter and a buffer, and each splicing operation can be performed in a start-end region of an md file to generate a splicing code, wherein the generation code of the embodiment is as follows:
after the text code layer is generated, an executable file is generated by a compiler tool such as a compiler or an assembler of the programming language used.
The invention relates to an internal design and implementation method of a modular programming component (a code module, a data set, a code module interface, a code module adapter and a module splicing domain) and a visualization layer mapping implementation method.
Claims (8)
1. A visual development implementation system of a module-level code structure is characterized by comprising three layers of structures: the system comprises a text code layer, a file management layer and a code expression layer, wherein the text code layer is used for writing an operation sequence, an operation and a data structure of a code expression program through traditional characters and storing the operation sequence, the operation and the data structure in the file; the visual development layer is a code structure which represents an operation sequence, an operation and a data structure in a graphic image mode, and expresses the execution sequence, the data transmission direction and the structure of the whole program according to the position relation and the splicing direction of the three; compiling the final source code of the text code layer into an executable file by a compiler of the adopted programming language; the text code layer comprises a data set structure, a code module interface, a code module adapter or a buffer and a module splicing domain; the visual development layer comprises visual elements corresponding to four structures, namely a data set structure, a code module interface, a code module adapter or a buffer and a module splicing domain in the text code layer, wherein the visual elements are two-dimensional graphs or three-dimensional models;
the text code layer adopts any object-oriented programming language, constructs a functional module, a code module interface, a code module adapter or buffer and a module splicing domain on a language class and a code structure of an object, defines and writes code materials in a text mode and assembles the materials into a complete program or software by splicing sentences in the splicing domain, wherein the code materials comprise variables, functions, classes, functional modules, module interfaces, module adapters and data sets.
2. The system of claim 1, wherein the functional module comprises an internal structure comprising: the material library reference declaration area, the global variable declaration and definition area, the schema definition area, the interface definition area, the work code area, the function, the class definition and the implementation area.
3. The system of claim 2, wherein the schema definition area comprises one or more module schema definitions, and the module schema controls the module to implement the function by controlling whether the module statement executes and whether the interface is enabled.
4. The system of claim 3, wherein the code module interface is configured to describe a manner in which data transmission variables exist during module splicing and a transfer direction of variable values, the transfer manner includes value transfer and depth transfer, and the transfer direction includes transmission in and transmission out.
5. The system of claim 4, wherein the code module adaptor is configured to accept variables output from the two-party or multi-party module interface, perform programmed operation on the variables, and determine whether to output, what type to output, and what value to output, so as to eliminate mismatching between data amount, data type, and data order in the module interface.
6. The system for realizing visualized development of the module-level code structure according to claim 1 or 5, wherein the module splicing domain comprises an external reference declaration area, a global top-level variable declaration and definition area, an internal work code area and a domain-level material definition area, and modules are vertically and horizontally spliced by using splicing statements in the work area.
7. The system according to claim 6, wherein the visualization development layer encapsulates the code structure into a two-dimensional planar graph, and the two-dimensional planar graph is used as a visual material and is spliced into a desired program through dragging and splicing operations to complete development.
8. The system of claim 7, wherein the mapping between the visualization development layer and the code layer is as follows: and translating the code module, the data set, the code module interface and the code module adapter into a text code in the module splicing domain, wherein the code module, the data set, the code module interface and the code module adapter correspond to the two-dimensional plane graph one by one, declaring in the module splicing domain, and translating the vertical and horizontal splicing relation of the elements of the visual development layer and the transmission relation of the data set, the module interface and the module interface adapter into the text code in the module splicing domain.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN201910104818.0A CN109976747B (en) | 2019-02-01 | 2019-02-01 | Visual development implementation system of module-level code structure |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN201910104818.0A CN109976747B (en) | 2019-02-01 | 2019-02-01 | Visual development implementation system of module-level code structure |
Publications (2)
| Publication Number | Publication Date |
|---|---|
| CN109976747A CN109976747A (en) | 2019-07-05 |
| CN109976747B true CN109976747B (en) | 2022-05-13 |
Family
ID=67076884
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN201910104818.0A Expired - Fee Related CN109976747B (en) | 2019-02-01 | 2019-02-01 | Visual development implementation system of module-level code structure |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN109976747B (en) |
Families Citing this family (4)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN110377280A (en) * | 2019-07-29 | 2019-10-25 | 郑州幻视科技有限公司 | A kind of visualization system for teaching programming |
| CN111258571A (en) * | 2020-02-11 | 2020-06-09 | 达闼科技（北京）有限公司 | Robot application program development method, system, device and storage medium |
| CN112364107A (en) * | 2020-11-10 | 2021-02-12 | 平安普惠企业管理有限公司 | System analysis visualization method and device, electronic equipment and computer readable storage medium |
| CN117608555B (en) * | 2023-11-28 | 2024-08-02 | 浙江大学 | Programming auxiliary method and system supporting creative and graphical |
Citations (3)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN1567201A (en) * | 2003-06-11 | 2005-01-19 | 深圳市蓝津信息技术有限公司 | Restructurable virtual device for software bus and chip structure |
| CN1737755A (en) * | 2005-06-13 | 2006-02-22 | 浙江大学 | Modeling and code generating method of embedded real-time operating system |
| CN102622259A (en) * | 2012-02-17 | 2012-08-01 | 南京南瑞继保电气有限公司 | Functional block function modeling method for visual programming |
Family Cites Families (1)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| EP3635538A4 (en) * | 2017-06-05 | 2021-03-10 | Umajin Inc. | Methods and systems for an application system |
-
2019
- 2019-02-01 CN CN201910104818.0A patent/CN109976747B/en not_active Expired - Fee Related
Patent Citations (3)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN1567201A (en) * | 2003-06-11 | 2005-01-19 | 深圳市蓝津信息技术有限公司 | Restructurable virtual device for software bus and chip structure |
| CN1737755A (en) * | 2005-06-13 | 2006-02-22 | 浙江大学 | Modeling and code generating method of embedded real-time operating system |
| CN102622259A (en) * | 2012-02-17 | 2012-08-01 | 南京南瑞继保电气有限公司 | Functional block function modeling method for visual programming |
Non-Patent Citations (2)
| Title |
|---|
| Design of object oriented finite element code;Z Bittnar 等;《object-oriented visual code development》;20011130;759-767 * |
| 基于Java与UML的应用程序开发;巴才国;《中国优秀硕士学位论文全文数据库_信息科技辑》;20040415;I138-455 * |
Also Published As
| Publication number | Publication date |
|---|---|
| CN109976747A (en) | 2019-07-05 |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| CN109976747B (en) | Visual development implementation system of module-level code structure | |
| Lattner et al. | MLIR: A compiler infrastructure for the end of Moore's law | |
| Lattner et al. | MLIR: Scaling compiler infrastructure for domain specific computation | |
| US8701087B2 (en) | System and method of annotating class models | |
| Schlenoff et al. | A robust process ontology for manufacturing systems integration | |
| KR20080106550A (en) | Declarative definition enabling graphical designer reuse | |
| Freeman-Benson et al. | The design and implementation of Kaleidoscope'90-A constraint imperative programming language. | |
| CN110673844A (en) | Image processing software development method and system | |
| Liu et al. | IGScript: An interaction grammar for scientific data presentation | |
| McGuire et al. | Abstract shade trees | |
| Farias et al. | UML2Merge: a UML extension for model merging | |
| Dillon et al. | Inference graphs: A computational structure supporting generation of customizable and correct analysis components | |
| Pombrio et al. | Inferring scope through syntactic sugar | |
| Novak | Creation of views for reuse of software with different data representations | |
| English et al. | OntoAgent: Implementing content-centric cognitive models | |
| Dalibor et al. | Mind the gap: lessons learned from translating grammars between MontiCore and Xtext | |
| Amor | A generalised framework for the design and construction of integrated design systems | |
| Berry et al. | Towards coq-verified esterel semantics and compiling | |
| Leite et al. | Designing and executing software architectures models using SysADL Studio | |
| Montag et al. | Bringing together dynamic geometry software and the graphics processing unit | |
| Jarzabek et al. | Towards a precise description of reverse engineering methods and tools | |
| Jackson | Software Abstractions, Revised Edition: Logic, Language, and Analysis | |
| CN112835567A (en) | Visual intelligent contract development system based on natural language | |
| Warren | The coroutine model of attribute grammar evaluation. | |
| RIKAČOVS et al. | An Overview of Practical Applications of Model Transformation Language L0. |
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 | ||
| GR01 | Patent grant | ||
| GR01 | Patent grant | ||
| CF01 | Termination of patent right due to non-payment of annual fee | ||
| CF01 | Termination of patent right due to non-payment of annual fee |
Granted publication date: 20220513 |