CN109976747B - A Visual Development and Implementation System of Module-level Code Structure - Google Patents

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

A Visual Development and Implementation System of Module-level Code Structure

technical field

The invention relates to the fields of code writing and software development, in particular to a modularized visual development system composed of a modularized development code structure and a module-level visual development method.

Background technique

With the increasing complexity and demand of software, enterprises and developers pay more attention to the rapid construction and code reuse of software engineering. On the one hand, software with a high degree of complexity needs a programming method that can clearly describe the relationship between software architecture and functional blocks, so as to improve the reusability and maintainability of software development; on the other hand, the popularity of the Internet and the Internet of Things makes more Many non-computer professionals have programming needs, but they cannot complete all the development independently due to their own programming level. Therefore, a programming method that can sustainably utilize the code resources in the developed field for simplified development is also required.

From the perspective of programming languages and programming methods, the current programming methods are process-oriented and object-oriented. The highest structure level of process-oriented is function level, and the highest structure level of object-oriented is object level. The association between process-oriented programming variables and functions It is weak in nature and difficult to reuse code; although the code reuse rate is obviously high in object-oriented programming, the relationship between objects is complex, so the constructed object relationship diagram is too complex to support visual programming.

From the practical point of view of visual programming technology, at present, visual programming mainly abstracts statements, functions and variables visually, and the visual elements correspond to one of them. However, its code reuse rate is low and development efficiency is low. It is mainly used for children's programming enlightenment. , which cannot be used in actual builds.

SUMMARY OF THE INVENTION

In order to solve the problems in the related art, an embodiment of the present invention provides a visual development and implementation system of a module-level code structure.

A visual development and realization system of a module-level code structure, including three-layer structure: 1. a text code layer, in which the operation sequence, operation operation and data structure of a program are expressed by writing codes through traditional characters, and stored in a file; Second, the visual development layer is a code structure that represents the operation sequence, operation operation and data structure in the form of graphics and images, and expresses the execution sequence of the program, the direction of data transmission, and the structure of the entire program by the positional relationship and splicing direction of the three; three , The compiler of the programming language used to compile the final source code of the text code layer into an executable file. specific:

The text code layer includes data set structure, code module interface, code module adapter or buffer, and module splicing domain; the visual development layer includes the data set structure, code module interface, code module adapter or buffer, and module splicing domain in the text code layer. The visualization elements corresponding to the four structures are two-dimensional graphics or three-dimensional models.

The text code layer adopts any object-oriented programming language, and constructs functional modules, module interfaces, module adapters, and module splicing fields on the code structure of language classes and objects, and defines and writes code materials in text mode. In the splicing domain, the material is assembled into a complete program or software with a splicing statement, and the code material includes variables, functions, classes, function modules, module interfaces, module adapters, and data sets.

Function module, its internal structure includes: material library reference declaration area, global variable declaration and definition area, mode definition area, interface definition area, working code area, function, class definition and implementation area; the mode definition area contains one or more modules Mode definition, the module mode controls the function realization of the module by controlling whether the statement in the module is executed and whether the interface is enabled.

The code module interface is used to describe the mode of data transmission variables and the transmission direction of variable values when the modules are spliced. The transmission mode includes value transmission and depth transmission, and the transmission direction includes incoming and outgoing.

The code module adapter is used to accept the variables output in the module interface of two or more parties, perform programming operation processing on the variables, and decide whether to output, what type and value to output, so as to eliminate the data volume and data in the module interface. Mismatch of type and data order.

The module splicing area includes an external reference declaration area, a global top-level variable declaration and definition area, a work code area (Workspace) in the area, and a domain-level material definition area, and the splicing statement is used in the work area to perform vertical (sequential execution) on the module. ) and horizontal (parallel execution) splicing.

The visual development layer encapsulates the code structure concretely into a two-dimensional plane graphic, takes the two-dimensional plane graphic as a visual material, and splices it into a required program through dragging and splicing operations to complete the development.

The mapping between the visual development layer and the code layer is as follows: the code module, data set, code module interface, code module adapter and two-dimensional plane graphics are in one-to-one correspondence, declared in the module splicing domain, and visualized development The vertical and horizontal splicing relationships of the elements of the layer and the transmission relationship of the data set, the code module interface, and the code module adapter are translated into text codes in the module splicing domain.

The use method of the present invention includes:

① Software development is carried out directly in the text code layer according to the above design;

②In the visual code layer, the visual elements are formed into a whole by dragging, splicing, and configuring operations to complete the software development. Finally, the visual compilation system translates the visual layer content into text code. The system achieves high aggregation of program functions in code modules through a new code structure design, combining object-oriented programming and process-oriented programming in software engineering theory. The structure below the module adopts object-oriented programming, and the structure above the module adopts process-oriented programming , Object-oriented programming initially guarantees the code reuse rate and the convenience of software development, while process-oriented programming emphasizes the orderliness of the code structure and further improves the code reuse rate.

The beneficial effects brought by the present invention are:

It makes the code structure of program writing and software development clear, improves the code reuse rate, realizes the visual development of module-level software or programs, and enables non-computer professionals to use the developed code modules to complete development through simple operations, reducing software costs. development threshold.

Description of drawings

In order to illustrate the technical solutions in the embodiments of the present invention more clearly, the following briefly introduces the accompanying drawings used in the description of the embodiments. Obviously, the drawings in the following description are only an embodiment of the present invention. , for programming language and compiler designers can migrate variants to design other implementation paths.

FIG. 1 is a diagram showing the mapping relationship between the visual development layer and the text code layer using the system of the present invention.

FIG. 2 is a diagram showing the use effect of the visualization software developed based on the realization of the system of the present invention.

FIG. 3 is a flow chart of the generation of the system of the present invention from the visual development layer to the final executable file.

Detailed ways

In order to make the objectives, technical solutions and advantages of the present invention clearer, the embodiments of the present invention will be further described in detail below with reference to the accompanying drawings.

In order to facilitate the understanding of the technical solutions provided by the embodiments of the present invention, the code structure of the 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 Figure 1, the text code layer includes data set structure, code module interface, code module adapter or buffer, and module splicing domain; the visual development layer includes the data set structure, code module interface, code module adapter or Visual elements corresponding to the four structures of the buffer and module splicing domain, and the visual elements are 2D graphics or 3D models.

Text code layer function module: It is a code module with highly aggregated functions. Each module can complete one or more functions without relying on any code except the external dependencies in the reference declaration area. The internal structure includes external application declaration, module Interfaces, module patterns, working code areas, internal variable declarations, function and class definitions.

Data set: It is a set of variables of various types with initial values arranged in order.

Module interface: It is the matching slot of the data exchange channel when the modules are spliced. In it, the variable type, variable name, variable value transfer mode, and variable direction are declared.

Code module adapter: The adapter is used to connect the mismatched (including data quantity, data type, data location) interface through processing, which includes the declaration and definition of new data, and contains the module interface data and adapter internal new declaration or Defines the code to perform arithmetic processing on the data.

Module splicing domain: The module splicing domain is to splicing code modules to form a new code module or constitute the final top-level of the software, allowing nesting definition. It includes the external reference declaration area, the global top-level variable declaration and definition area, the internal work code area (Workspace), and the domain-level material (adapter, class, function, data set) definition area.

The visual elements in the visual layer in the module-level visual programming system are mainly to visualize the high-level code structure of the text code layer into a two-dimensional or three-dimensional graphic image, including:

Start module: Corresponding to the function module of the text code layer, it represents the first start function module of the program. There is only one for each splicing field. For the convenience of identification, it is independently identified.

End module: Corresponding to the function module of the text code layer, it represents the last executed function module of the program, each splicing domain can have multiple, and is identified independently for the convenience of identification.

Visual development layer functional modules: Corresponding to the functional modules of the text code layer, all functional modules except the start module and the end module are represented in the visual layer, which can be spliced with the start module, end module, module adapter, other functional modules, and data sets .

Module interface: Corresponding to the module interface of the text code layer, it is expressed as a channel connecting modules (including: start module, end module, and function module) in the visualization layer.

Module adapter: Corresponding to the module adapter of the text code layer, in the visualization layer, it is mainly displayed as splicing with two (or more modules) at the same time. This method means that the interface data processing spliced on one side is transmitted to the module on the other side. Internal interface; the other is splicing with the module and the data set at the same time, which means that the data of the data set is processed and transmitted to the module on the other side.

Data set: Corresponding to the data set of the text code layer, it is visualized as an element spliced with the module interface or module adapter, indicating that a value is passed or assigned to the spliced element.

Module splicing domain: Corresponding to the module splicing domain of the text code layer, in the visualization layer, it is expressed as a workspace for splicing operations of other visual elements, and corresponds to an entity file.

The code example of the text code layer function module module code is as follows:

The above code is a specific code module designed according to the method of the present invention. The keyword "import" guides the external dependency declaration; the indented content of the keyword "pattern" is the definition of the module pattern label; the keyword "interface" The content of the next guide is the declaration and definition of the interface, and each module can define more than one; the scope of the keyword "start-end" is the code workspace. When the module is started, the statements in this scope will be executed in turn, and the execution The process will be selectively executed according to the pattern label; the final part is to declare and define the internal functions and classes required by the module. The content in the above modules can be defaulted except the code workspace of "start-end", and the expressions such as keywords can be changed accordingly, as long as the module components (module interface, module mode) function design and code execution The same conditions as those described in the present invention fall within the scope of the present invention.

A data set is a series of ordered variable sets with initial values. Formally, it is a structure, but it is emphasized that each variable must have an initial value, and the order in which they appear has meaning, which will be recognized by the compiler as information collection. , for matching when the interface is passed in, the data set code is as follows:

The code module adapter is to calculate and transform the data sent out from the interface when the two or more parties of the module interface do not match, and output it to the variable to be passed in the interface of the other party. If the output data of the interface is redundant, it will be ignored. . The code module adapter has three main functions, receiving data, processing data, and outgoing data. The code module adaptation code example is as follows:

In the above code, the keyword "adapter" indicates the beginning of the adapter definition, "adapterName" is the name of the adapter, and "[]" is the interface handled by the adapter. The subsequent code is to process the unmatched data, guided by ">>:" The indented content is the final data transfer. The design of the adapter is not limited to the type of programming language, expression form, and writing format, as long as the content and functional characteristics conform to the content of the present application, it falls within the scope of the present invention.

The module splicing domain is the highest-level code structure in the present invention, and is used for splicing code modules to complete required functions or form new code modules. The internal structure includes: external reference declaration area, global top-level variable declaration and definition area, internal work code area (Workspace), and domain-level material (adapter, class, function, data set) definition area.

The specific code example is as follows:

In the code of the above-mentioned embodiment, what is guided within the scope of the keyword "start-end" is that conventional code statements (including operation statements, control flow statements) and module splicing statements can be carried out in the code work area, wherein "module_1<patt_1>(inter_1, inter_2)" statement four module startup statements, "module_1" is the module name, "<>" is the module mode label, "()", "|" The leading statement is the input of the data set or the use of the adapter. Statements in the code work area are executed sequentially from top to bottom. Similarly, the module splicing field can be not limited to language, expression, and writing format. All functional designs that meet the requirements of the present invention are within the scope of the present invention.

In order to illustrate the generation method from the visualization layer to the text code layer, the method will be specifically described below around the embodiment in FIG. 2 :

In the work area on the right side of Figure 2, splicing is performed. The blue triangle "start" module is essentially a module, and its function is to start when the domain is started. Each domain can only have one; the red "end" module and "" "start" is similar, but each field can have multiple; the purple square modules are common function modules; the black "adapter_1" is the adapter; the yellow "buffer_1" is the buffer module, the buffer is essentially derived from the adapter, except It is no different from an adapter except that it can store data and has a long life cycle.

For this embodiment of the visual development layer, a processing method and a processing procedure are shown in FIG. 3 . Each splicing field will generate a *.md file in the computer hard disk, which is the splicing field text code file, which contains the code of the specific programming language.

When dragging a visual element into the mosaic area, a reference declaration is generated in the reference declaration area in *.md according to the file name and storage path of the element. In addition to the module, adapter, and dataset reference declaration, if the programming language uses other external resources, such as Classes, functions, etc. are also automatically generated, and the reference declaration generated by this implementation is as follows:

The above reference does not involve a specific storage address, and the compiler automatically obtains the content of the relevant file from the set connection path.

The creation of new modules or related accessories needs to be written in text mode, and the present invention only applies to the internal realization method and macro splicing and mapping method of modules and accessories.

After the module and the module are spliced, the user needs to set the docking interface and the module startup mode. These two pieces of information are not reflected in the figure, but are selected and input by the user and recorded in the system. , the buffer connection does not appear gray connection mark, each splicing operation will generate splicing code in the "start-end" area of the *.md file, the generated code in this embodiment is as follows:

After the text code layer is generated, an executable file is generated by compiling tools such as the compiler and assembler of the programming language used.

The present invention is a modular programming component (code module, data set, code module interface, code module adapter, module splicing domain) internal design and implementation method and visualization layer mapping implementation method. According to the description made by a programming language designed and implemented by the method of the present invention, a technical person with a computer foundation, programming language and compiler designer can realize the effect according to the method of the present invention, so the present invention does not Limited to programming languages, expressions and writing formats, all components that conform to the design and implementation ideas of the components described in the present invention fall within the scope of the present invention.

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.

Images