A neural network-based software progressive evolution development method and system

Abstract

This invention discloses a method and system for incremental software development based on neural networks, relating to the field of software engineering technology. The method includes: constructing scripts for each incremental layer node and output layer node in a neural network-style node dependency structure; using the output of the dependent node as input and combining it with the needs of the current node to generate output content, forming input layer nodes, incremental layer nodes, output layer nodes, and the dependencies between nodes; constructing a project overview network diagram based on the input layer nodes, incremental layer nodes, output layer nodes, and the dependencies between nodes; locating and color-coding change nodes and change levels in the project overview network diagram; and propagating the impact of changes layer by layer along the dependency path to obtain a consistent hierarchical dependency structure and the output content of the output layer. This invention improves the iterative controllability, structural consistency, and reliability of final delivery in the application software development process.

Description

Technical Field

[0001] This invention relates to the field of software engineering technology, and in particular to a method and system for incremental software development based on neural networks. Background Technology

[0002] Layering, modularization, and object-oriented modeling concepts have been introduced into software engineering to guide the structural partitioning, functional abstraction, and dependency management of complex systems. A common approach in existing technologies is to divide the software system according to functional modules or abstraction levels, describing the dependencies between modules through directory structures, configuration files, and build scripts, and combining this with automated build tools to achieve continuous integration and continuous delivery. In application software development practice, this type of technology can improve system maintainability and scalability to a certain extent, while reducing the complexity of collaborative development through standardized project structures.

[0003] Existing technologies for describing software architecture evolution and the propagation of changes typically employ module- or package-level dependency analysis. While this approach can reflect basic call relationships, it provides a relatively coarse depiction of fine-grained relationships between nodes within a hierarchy. When a functional node is adjusted, the impact of the change often requires manual analysis or additional tools to track, making it difficult to visually represent its propagation along dependency paths within a unified architecture. Summary of the Invention

[0004] In view of the aforementioned existing problems, the present invention is proposed.

[0005] Therefore, this invention provides a neural network-based incremental software development method. On the one hand, by adding a time dimension to the existing spatial dimension based on logical relationships, the granularity of the partitioning is made finer, the development difficulty is reduced, and the development efficiency is improved; moreover, in development practice, agile development processes can be adopted more naturally. On the other hand, it can solve the problems of insufficient characterization of fine-grained dependencies between nodes within a hierarchy and the difficulty in intuitively and uniformly presenting the propagation of changes along dependency paths.

[0006] To solve the above-mentioned technical problems, the present invention provides the following technical solution: In a first aspect, the present invention provides a software incremental development method based on neural networks, which includes: establishing a project, and establishing an input layer, an output layer and an incremental layer under the project to form an initial structure; Within the input layer, progressive layer, and output layer defined by the initial structure, hierarchical nodes are established to form a neural network-like node-dependent structure; In a neural network-style node dependency structure, scripts are built for each progressive layer node and output layer node. The output of the dependent node is used as input, and the output content is generated in combination with the needs of the node to produce a software distribution package.

[0007] As a preferred embodiment of the neural network-based software incremental development method of the present invention, the establishment of a project refers to naming the project with a project name and saving the basic information of the project as structured content through structured processing.

[0008] As a preferred embodiment of the neural network-based incremental software development method of the present invention, the specific steps of establishing an input layer, an output layer, and an incremental layer under the project to form an initial structure are as follows: Establish a lower-level structure under the project, and agree that Input is the input layer and Output is the output layer, and agree that the sequence number is used to name each progressive layer; The basic information of the corresponding layer is saved in the input layer, output layer and each progressive layer, and together with the project, they form the initial structure.

[0009] As a preferred embodiment of the neural network-based software incremental development method of the present invention, the step of establishing hierarchical nodes within the input layer, progressive layer, and output layer defined by the initial structure to form a neural network-like node-dependent structure includes the following specific steps: Within the input layer defined by the initial structure, the node division is determined according to each requirement point; In the initial directory structure, the progressive layer and the output layer are locked as the processing scope. First, the progressive layer is sorted according to its hierarchical order, and finally the output layer is added. Based on the principle of software abstraction hierarchy progression, hierarchical carrying nodes are set for each sorted directory. Based on the progressive dependency chain, each level of node stores node descriptions and information about the set of dependent nodes, forming a neural network-like node dependency structure.

[0010] As a preferred embodiment of the neural network-based software incremental development method of the present invention, the specific steps of constructing scripts for each incremental layer node and output layer node in the neural network node dependency structure, using the output of the dependent node as input, and combining the needs of the current node to generate output content are as follows: In a neural network-based node dependency structure, progressive layer nodes and output layer nodes are identified as script configuration objects, and the input source of each node's processing script is determined based on the set of dependent nodes recorded in the node information. The processing scripts of the progressive layer nodes and the output layer nodes read the output content from the dependent nodes, combine it with the needs of the current node to form the output content of the current node and save it, thus forming the input layer nodes, progressive layer nodes, output layer nodes and the dependencies between the nodes. Based on the input layer nodes, progressive layer nodes, output layer nodes, and the dependencies between nodes, construct a project overview network diagram according to the progressive dependency chain. In the project overview network diagram, the current input layer nodes, progressive layer nodes, output layer nodes, and the dependencies between nodes are compared with the previous version's input layer nodes, progressive layer nodes, output layer nodes, and the dependencies between nodes to identify the nodes whose output content has changed, obtain the changed nodes, and determine the changed level based on the hierarchical position of the changed nodes in the project overview network diagram. In the project overview network diagram, apply a first preset color mark to the change node and a second preset color mark to the change level; The changed node is identified as the starting node for the propagation of the change's impact based on the color markings. Then, starting from the starting node, downstream nodes are searched along the dependency directions represented by the directed lines in the project overview network diagram. The propagation is carried out layer by layer down the dependency path, with downstream nodes as the propagation objects. The affected downstream nodes and their corresponding levels are associated and marked to form a consistent hierarchical dependency structure. The script is then executed on the output layer nodes in the consistent hierarchical dependency structure to obtain the output content of the output layer nodes.

[0011] As a preferred embodiment of the neural network-based software incremental development method of the present invention, the specific steps for generating the software distribution package are as follows: Based on a consistent hierarchical dependency structure, the output layer node is determined as the publishing target, and the set of output layer content is obtained from the output layer node; The output layer content set is validated, and after the validation passes, the corresponding build script is called according to the preset build rules of the output layer node to compile the output layer source code and package the configuration file together to generate a software distribution package.

[0012] Secondly, the present invention provides a software incremental development system based on neural networks, comprising: a project architecture initialization module for creating a project, and creating an input layer, an output layer and an incremental layer under the project to form an initial directory structure; The node dependency structure building module is used to establish hierarchical nodes within the input layer, progressive layer, and output layer defined by the initial directory structure, forming a neural network-like node dependency structure. The script execution build and release module is used to build scripts for each progressive layer node and output layer node in a neural network node dependency structure. It takes the output of the dependent node as input and combines it with the needs of the node to generate output content and produce a software release package.

[0013] The beneficial effects of this invention are as follows: by organizing the application software development process into a hierarchical node structure similar to a neural network, and automatically identifying the change location and impact level with the help of the project overview network diagram when a node changes, the change is propagated layer by layer along the dependency path to form a consistent hierarchical dependency structure, so that software modifications can be accurately perceived, automatically linked and consistently updated, effectively avoiding missed updates and invalid refactoring, and improving the iterative controllability, structural consistency and final delivery reliability in the application software development process. Attached Figure Description

[0014] To more clearly illustrate the technical solutions of the embodiments of the present invention, the drawings used in the following description of the embodiments will be briefly introduced. Obviously, the drawings described below are only some embodiments of the present invention. For those skilled in the art, other drawings can be obtained based on these drawings without creative effort.

[0015] Figure 1 This is a flowchart of a neural network-based incremental software development methodology.

[0016] Figure 2 This is a schematic diagram of a neural network-based software incremental evolution development system.

[0017] Figure 3 This is a flowchart of neural network-style node dependency processing.

[0018] Figure 4 Generate a flowchart for the software release package. Detailed Implementation

[0019] To make the above-mentioned objects, features and advantages of the present invention more apparent and understandable, the specific embodiments of the present invention will be described in detail below with reference to the accompanying drawings.

[0020] Many specific details are set forth in the following description in order to provide a full understanding of the invention. However, the invention may also be practiced in other ways different from those described herein, and those skilled in the art can make similar extensions without departing from the spirit of the invention. Therefore, the invention is not limited to the specific embodiments disclosed below.

[0021] Secondly, the term "one embodiment" or "embodiment" as used herein refers to a specific feature, structure, or characteristic that may be included in at least one implementation of the present invention. The phrase "in one embodiment" appearing in different places in this specification does not necessarily refer to the same embodiment, nor is it a single or selective embodiment that is mutually exclusive with other embodiments.

[0022] Reference Figures 1-4 This is one embodiment of the present invention, which provides a method for incremental software development based on neural networks, including the following steps: S1. Create a project directory and a project info file. Under the project directory, create an input layer directory, an output layer directory, and a progressive layer directory, and set up info files for each level to form the initial directory structure.

[0023] S1.1 Create a folder named after the project under the preset storage path, and designate the folder as the project directory. Generate an info file in the project directory, and write the basic project information into the info file through structured processing to form structured content.

[0024] Furthermore, a folder named after the project is created under the preset storage path, and this folder is designated as the project directory. An info file is then generated in the project directory. Basic project information is extracted from the project name, the preset storage path, and the project directory hierarchy. This basic project information is then structured according to the correspondence between "field names and field values." Field names use fixed text expressions that can distinguish meanings, and field values ​​use the text content corresponding to the basic project information. The structured content is then written into the info file in a sequentially readable plain text format. The writing process includes creating, opening, writing, and saving the info file. After writing is complete, a project info file containing the basic project information is obtained, and the project info file is stored in the project directory.

[0025] It should be noted that the preset storage path is obtained by selecting an existing file storage location with read and write permissions in the operating environment and recording the selected file storage location as the path information for storing the project directory.

[0026] S1.2 Create folders named Input and Output in the project directory, and use the Input and Output folders as the input layer directory and output layer directory, respectively. Create folders named with hierarchical numbers in the project directory and designate the folders named with hierarchical numbers as the progressive layer directories.

[0027] Furthermore, folders with fixed names "Input" and "Output" are created in the project directory. The creation process includes performing folder creation operations in the project directory path, reading the created folder names and comparing them character by character with "Input" and "Output". If the character-by-character comparison matches, the "Input" folder is determined as the input layer directory and the "Output" folder is determined as the output layer directory. Folders named with hierarchical numbers are also created in the project directory. The hierarchical number naming method uses folder names containing only hierarchical number characters. The folder creation method is the same as the folder creation operations for the "Input" and "Output" folders. After the folders named with hierarchical numbers are created, the folder names named with hierarchical numbers are read and compared character by character with the expected hierarchical number characters. If the character-by-character comparison matches, the folder named with hierarchical numbers is determined as the progressive layer directory. Thus, a hierarchical directory structure of input layer directory, output layer directory, and progressive layer directory is formed in the project directory.

[0028] S1.3 Create a hierarchical info file with a fixed name in the input layer directory, output layer directory, and each progressive layer directory. Write the basic project information of the corresponding level into the hierarchical info file, and together with the project info file, form the initial directory structure.

[0029] Furthermore, create hierarchical info files with the fixed name "info" in the input layer directory, output layer directory, and each progressive layer directory; read the basic project information corresponding to the input layer directory, output layer directory, and progressive layer directory from the project info files in the project directory, and write the read basic project information into the hierarchical info files of the input layer directory, the output layer directory, and each progressive layer directory in structured text format, so that the project info files and each hierarchical info file together constitute the initial directory structure.

[0030] S2. Within the input layer, progressive layer, and output layer defined by the initial directory structure, create node info files and out subdirectories for the hierarchical nodes to form a neural network-style node dependency structure.

[0031] S2.1 In the initial directory structure, the progressive layer directory and the output layer directory are locked as the processing scope. First, sort them according to the hierarchical order of the progressive layer, and finally add the output layer. Based on the software abstraction hierarchical progression principle, set the hierarchical carrying node for each sorted layer directory, and record the unique node identifier composed of layer name and node name.

[0032] Furthermore, after defining the progressive layer directory and output layer directory as the processing scope in the initial directory structure, the progressive layer directories are sorted in ascending order according to their hierarchical numbers, and the output layer directories are appended to the end of the sorting results to form the processing order. In the processing order, the hierarchical info files of each progressive layer directory and the output layer directory are read sequentially to extract the layer name information and use it as the layer name. For each progressive layer directory and output layer directory, the node name of the layer-bearing node is determined according to the principle of progressive software abstraction hierarchy, and the node name corresponding to the layer-bearing node is written into the hierarchical info file of the corresponding layer. The layer name and node name are connected in the form of "layer name-node name" to generate a unique node identifier, and the unique node identifier is recorded in the hierarchical info file of the corresponding layer for subsequent dependency recording and node directory creation.

[0033] S2.2 Determine the dependency direction from the dependent node to the dependent node according to the hierarchical dependency rules, and establish the dependency relationship between the progressive layer node and the output layer node to the preceding layer node according to the dependency direction and the unique node identifier, forming a progressive dependency chain.

[0034] Furthermore, based on the fact that the progressive layer directory and output layer directory have been sorted hierarchically and unique node identifiers have been generated, the dependency direction is determined according to the hierarchical dependency rules as "the dependent node points to the dependent node". These hierarchical dependency rules include at least three rules: hierarchical constraint rules, type compatibility rules, and nearest-layer priority rules. Hierarchical constraint rules restrict dependent nodes to nodes located at levels preceding them in the dependency hierarchy. Type compatibility rules restrict dependent nodes to being candidates only if their output content structure identifier matches the input requirement structure identifier of the dependent node. The nearest-layer priority rule prioritizes the node with the closest hierarchical number when candidates exist. First, for each progressive layer node and each output layer node, read the unique node identifier recorded in the corresponding layer's info file, and retrieve all unique node identifiers in the preceding layers in the hierarchical order as an optional set of dependent nodes; determine the actual set of dependent nodes from the optional set of dependent nodes, and write the unique node identifiers of the actual set of dependent nodes into the node info files of the progressive layer nodes and the output layer nodes; record the dependency relationships in the direction of "unique node identifier of dependent node → unique node identifier of dependent node", and chain the dependency relationships of all progressive layer nodes and output layer nodes layer by layer to obtain a progressive dependency chain.

[0035] It should be noted that hierarchical constraint rules are the fundamental rules used to limit the scope of node dependencies. The rules state that any progressive layer node or output layer node is only allowed to depend on nodes at levels preceding it in the hierarchy order. Dependencies to nodes at the same or subsequent levels are prohibited, thus ensuring that dependencies are unidirectionally progressive in the hierarchy order and do not result in backtracking or loops. The hierarchical constraint rules are formulated based on the initial project directory structure, which first lists the input layer, then the progressive layer directories sorted by hierarchical number from smallest to largest, and finally the output layer at the end of the hierarchy. By comparing the hierarchical number of the dependent node with that of the candidate dependent node, only nodes with a lower hierarchical number are allowed to be included in the set of potential dependent nodes. Type compatibility rules are matching rules used to determine whether nodes have a valid data or result connection relationship. The rule states that a dependency relationship is only allowed if the output content type or structure identifier of a candidate dependent node matches the input content type or structure identifier required by the dependent node. Type compatibility rules are formulated by pre-recording the node's output content type or structure identifier and the node's required input content type or structure identifier in structured fields in the node's info file. When determining a dependency relationship, the output structure identifier of the candidate dependent node is compared one by one with the input requirement structure identifier of the dependent node. When the two are completely consistent or meet the preset compatibility correspondence, the corresponding candidate node is determined to be a type-compatible node and included in the compatible candidate set. The nearest-layer-first rule is a selection rule used to determine the actual order of dependent nodes when multiple type-compatible candidate dependent nodes exist. The rule states that, under the premise of satisfying hierarchical constraints and type compatibility rules, the node in the layer immediately preceding the dependent node whose hierarchical index is closest to the dependent node's hierarchical index is prioritized as the dependent node. This maintains the tightness of the progressively increasing dependency and the stability of the processing chain. The nearest-layer-first rule is formulated by first determining the set of compatible candidates, then sorting them according to the difference between the hierarchical index of the candidate dependent node and the hierarchical index of the dependent node, prioritizing the selection of the dependent node from the candidate node with the smallest hierarchical difference. When no compatible candidate node exists in the nearest preceding layer, the selection is then expanded layer by layer forward in ascending order of hierarchical difference, thus forming a dependency determination process from nearest to furthest.

[0036] S2.3. Based on the progressive dependency chain, create a node directory for each level of node, and create a node info file in the node directory, writing the node description and the set of dependent nodes into the node info file.

[0037] Furthermore, the unique node identifier corresponding to each level node in the progressive dependency chain is read one by one, and the layer name and node name are parsed from the unique node identifier; a folder named after the node name is created in the progressive layer directory or output layer directory corresponding to the layer name, and the folder named after the node name is determined as the node directory; a node info file with the fixed name "info" is created in the node directory, and the file name of the node info file is validated; the node description is written into the node info file, and the node description includes the requirement and dependent nodes; the set of dependent nodes corresponding to the unique node identifier in the progressive dependency chain is written into the node info file, and the dependent nodes are recorded in the form of a list of unique node identifiers.

[0038] S2.4. Create an "out" subdirectory under the node directory of the input layer node to store the requirement files. Create a "script" subdirectory and an "out" subdirectory under the node directories of the progressive layer and output layer nodes. Use the "script" subdirectory to carry the node processing scripts and use the "out" subdirectory as the output storage location. Dependencies are described through the node info file, which together form a neural network-style node dependency structure.

[0039] Furthermore, in the node directories of the progressive layer and output layer nodes, folders with fixed names of "script" and "out" are created respectively, and the folder names of the "script" folder and "out" folder are validated. The "script" folder is designated as the "script" subdirectory and used as the storage location for node processing scripts, and the "out" folder is designated as the "out" subdirectory and used as the storage location for node output content. A set of dependent nodes is written into the node info file, and the set of dependent nodes is recorded in the form of a list of unique node identifiers. The set of dependent nodes is used to express the dependency relationship where the dependent node points to the dependent node. The node info file, the "script" subdirectory, and the "out" subdirectory are retained in the node directories of the progressive layer and output layer, so that each level of node has a location for recording dependency relationships, a location for storing node processing scripts, and a location for storing node output. After connecting multiple levels of nodes according to a progressively advancing dependency chain, a neural network-like node dependency structure is formed.

[0040] S3. In the neural network node dependency structure, script files are built for the script subdirectories of each progressive layer node and the output layer node. The output of the dependent node is used as the input, and the output is generated to the out subdirectory in combination with the needs of this node, forming the input layer node, progressive layer node, output layer node and the dependency relationship between the nodes.

[0041] S3.1 In the neural network-style node dependency structure, the progressive layer nodes and output layer nodes are identified as script configuration objects, and the input source of each node script is determined according to the set of dependent nodes recorded in the node info file.

[0042] Furthermore, in the neural network-style node dependency structure, the node info files in all node directories are read, and progressive layer nodes and output layer nodes are distinguished from the node info files. The progressive layer nodes and output layer nodes are identified as script configuration objects. For each script configuration object, the corresponding node info file is opened and the set of dependent nodes is read. The set of dependent nodes exists in the form of a list of unique node identifiers. Based on the unique node identifiers in the set of dependent nodes, the node directory of the corresponding dependent node is located. The out subdirectory is located in the node directory of the dependent node, and the contents of the out subdirectory of the dependent node are identified as the input source of the script configuration object. The one-to-one correspondence between the set of dependent nodes and the input source is confirmed, providing a clear input path for subsequent script configuration.

[0043] S3.2 Configure script files in the script subdirectories of the progressive layer node and the output layer node. The scripts read the output content from the out subdirectory of the dependent node, combine it with the needs of this node to form the result and output it to the out subdirectory of this node, thus forming the input layer node, progressive layer node, output layer node and the dependency relationship between the nodes.

[0044] Furthermore, script files are created in the script subdirectory of each progressive layer node and the script subdirectory of each output layer node. The script file configuration process includes writing processing instructions for reading the output content of dependent nodes in the script subdirectory. When the script file is executed, it reads the output content from the out subdirectory of the dependent node corresponding to the set of dependent nodes recorded in the node info file. After reading the output content of the out subdirectory of the dependent node, the script file combines the node requirements recorded in the node info file of the progressive layer node or the output layer node to form a processing result. The script file writes the processing result to the out subdirectory of the corresponding progressive layer node or the output layer node, thereby forming the input layer node, progressive layer node, output layer node, and the dependency relationship between nodes in the neural network node dependency structure.

[0045] S4. Construct a project overview network diagram based on the input layer nodes, progressive layer nodes, output layer nodes, and the dependencies between nodes. Locate the change nodes and change levels in the project overview network diagram and mark them with colors. Pass the impact of the change along the dependency path layer by layer to obtain a consistent hierarchical dependency structure and the contents of the output layer node's out directory.

[0046] S4.1. Based on the input layer nodes, progressive layer nodes, output layer nodes, and the dependencies between nodes, construct a project overview network diagram according to the progressive dependency chain.

[0047] Furthermore, the node info files in all node directories are read one by one to obtain unique node identifiers and sets of dependent nodes. Based on the dependency directions recorded in the progressive dependency chain, the unique node identifiers are used as node elements and the dependencies are used as directed connections. During the construction process, the input layer nodes, progressive layer nodes, output layer nodes, and dependencies between nodes are associated with the unique node identifiers. By summarizing all node elements and directed connections, a project overview network diagram reflecting the hierarchical order and dependencies is formed.

[0048] S4.2 In the project overview network diagram, compare the current input layer nodes, progressive layer nodes, output layer nodes and their dependencies with the previous version's input layer nodes, progressive layer nodes, output layer nodes and their dependencies to determine the nodes whose content in the out subdirectory has changed, obtain the changed nodes, and determine the changed level based on the hierarchical position of the changed nodes in the project overview network diagram.

[0049] Furthermore, given that the project overview network diagram has been formed and the input layer nodes, progressive layer nodes, output layer nodes, and their dependencies have been associated with unique node identifiers, for each unique node identifier in the project overview network diagram, the contents of the `out` subdirectory in the corresponding node directory of the current input layer node, progressive layer node, output layer node, and their dependencies, as well as the contents of the `out` subdirectory in the corresponding node directory of the previous version's input layer node, progressive layer node, output layer node, and their dependencies, are compared. This comparison process includes comparing the contents of the current input layer node, progressive layer node, output layer node, and their dependencies. The set of file names in the `out` subdirectory of the dependency relationship is compared item by item with the set of file names in the `out` subdirectory of the previous version's input layer node, progressive layer node, output layer node, and the dependency relationships between nodes. If the set of file names matches, the content of the file with the same name is compared character by character. If any set of file names does not match or the content of the file with the same name does not match character by character, the corresponding unique node identifier is identified as the change node. After obtaining the change node, the layer name corresponding to the change node is read and the layer position corresponding to the layer name is located in the project overview network diagram. The layer position corresponding to the layer name is identified as the change layer, thus obtaining the change node and the change layer.

[0050] S4.3 Apply a first preset color mark to the change node and a second preset color mark to the change level in the project overview network diagram.

[0051] Furthermore, the process iterates through all unique node identifiers in the project overview network diagram and matches them against the list of unique node identifiers for the changed nodes. When a unique node identifier is successfully matched, the display attribute of the corresponding node element is updated to a first preset color marker, and a record relationship is established between the first preset color marker and the corresponding unique node identifier. Then, the process iterates through all hierarchical positions in the project overview network diagram and matches them against the list of layer names corresponding to the changed hierarchies. When a layer name is successfully matched, the display attribute of the corresponding hierarchical area is updated to a second preset color marker, and a record relationship is established between the second preset color marker and the corresponding layer name. After applying the first and second preset color markers, the project overview network diagram simultaneously possesses both changed node identifiers and changed hierarchical identifiers.

[0052] It should be noted that the first preset color mark is a color display attribute that is predetermined at the beginning of the project and is used to identify change nodes in the project overview network diagram. The first preset color mark selects a color from the set of displayable colors and records the selection result as the node-level identifier color. In the subsequent processing of the project overview network diagram, when a unique node identifier is determined to be a change node, the display attribute of the corresponding node element is set to the first preset color mark to achieve intuitive differentiation of change nodes. The second preset color mark is a color display attribute predetermined at the beginning of the project and is used to identify the change level in the project overview network diagram. The second preset color mark selects a color different from the first preset color mark from the set of displayable colors and records the selection result as the level identification color. In the subsequent processing of the project overview network diagram, when the level position corresponding to the level name is determined to be a change level, the display attribute of the corresponding level area is set to the second preset color mark to achieve overall identification of the change level range.

[0053] S4.4. Based on the color markings, identify the changed nodes as the starting nodes for the propagation of the changes, and starting from the starting node, search for downstream nodes along the dependent directions represented by the directed lines in the project overview network diagram.

[0054] Furthermore, by traversing the node elements in the project overview network diagram and reading their display attributes, node elements whose display attributes are equal to the first preset color mark are filtered out, and the unique node identifiers corresponding to the filtered node elements are determined as the starting nodes for the propagation of change effects. Starting from the starting node for the propagation of change effects, the set of directed connections originating from the starting node is read, and downstream nodes are located based on the unique node identifiers pointed to by the directed connections. During the search process, a set of visited node identifiers is used to record the unique node identifiers that have been traversed. For each newly located downstream node, if its unique node identifier does not exist in the set of visited node identifiers, the operation of reading the set of directed connections originating from the downstream node and locating the unique node identifier it points to is performed, and after the operation is completed, the unique node identifier of the downstream node is added to the set of visited node identifiers. When all downstream nodes to be traversed already exist in the set of visited node identifiers or there are no new directed connections pointing to unvisited unique node identifiers, the traversal process is terminated, thereby obtaining the set of downstream nodes reachable along the dependency direction while avoiding repeated traversal and loop access.

[0055] S4.5. Using downstream nodes as the propagation objects, propagate down the dependency path layer by layer, associate and mark the affected downstream nodes and their corresponding levels to form a consistent hierarchical dependency structure, and execute script processing on the output layer nodes in the consistent hierarchical dependency structure to obtain the contents of the output layer node's out directory.

[0056] Furthermore, taking downstream nodes as the propagation target, for each unique node identifier in the downstream node set, the corresponding node element is located in the project overview network diagram. Based on the pointing relationship of directed connections, the subsequent downstream nodes of the node element are retrieved. The retrieved subsequent downstream nodes are merged into the downstream node set and duplicate unique node identifiers are removed, thereby covering the dependency path from the starting node of the change to all reachable nodes. The unique node identifiers corresponding to the affected downstream nodes are read, the layer names obtained by parsing the unique node identifiers are read, and the layer positions corresponding to the layer names are located in the project overview network diagram. A one-to-one association record is established between the unique node identifiers and the layer names. After the association tagging record is completed, the set of node dependencies, including the starting node of the change impact propagation, the affected downstream nodes, and the corresponding level of the affected downstream nodes, is summarized into a consistent hierarchical dependency structure. The process of executing script processing on the output layer node in the consistent hierarchical dependency structure includes opening and executing the script files in the script subdirectory of the output layer node in the order of dependencies determined by the consistent hierarchical dependency structure. When the script file is executed, it reads the output content from the out subdirectory of the dependent node and writes the processing result to the out subdirectory of the output layer node, thus obtaining the content of the out directory of the output layer node.

[0057] S5. Based on the consistent hierarchical dependency structure and the contents of the output layer node out directory, aggregate, verify, and build the output layer source code and configuration to generate a software release package.

[0058] S5.1. Based on the consistent hierarchical dependency structure, determine the output layer node as the release target, and extract the output layer source code and configuration from the out directory of the output layer node to obtain the output layer content set.

[0059] Furthermore, the system reads a list of unique node identifiers in the consistent hierarchical dependency structure, where the layer name belongs to the output layer directory and the node type is output layer node. The output layer nodes corresponding to these unique node identifiers are then identified as the release targets. For each release target, the system locates the `out` subdirectory within the corresponding node directory and reads the set of file names within that subdirectory. The system then filters the file names in the file name set to match the output layer source code and configuration files, opening and reading the contents of each file. Finally, the system summarizes the read output layer source code and configuration files according to the correspondence between file names and file contents, forming a set of output layer content.

[0060] S5.2 Perform validation on the output layer content set. After the validation passes, call the corresponding build script according to the preset build rules of the output layer node, compile the output layer source code, and package the configuration file together to generate a software release package.

[0061] Furthermore, the system reads the output layer source code files and configuration files one by one from the output layer content set, and checks the file integrity, file readability, and file format consistency. When all verification items meet the requirements, the verification result is determined as verification passed. After verification, the system reads the preset build rules recorded in the node info file of the output layer node, and locates the corresponding build script according to the preset build rules. The corresponding build script is called to perform a compilation operation on the output layer source code. The compilation process includes reading the output layer source code and generating an executable or deployable compilation result. After compilation is completed, the compilation result and configuration file are packaged together to generate a software distribution package.

[0062] It should be noted that the build rules refer to a set of textual rules used to constrain the compilation method of the output layer source code and the packaging method of the configuration files, specifying the name of the compilation script, the compilation order, the type of compilation artifacts, and the configuration file merging method used by the output layer nodes when generating the software release package; The build rules are obtained by writing build rule content that matches the output layer source code type and release target into the node info file corresponding to the output layer node. The build rule content comes from the compilation environment requirements and configuration file combination requirements corresponding to the output layer source code.

[0063] This embodiment also provides a software incremental development system based on neural networks, including: a project initialization module, used to establish a project directory and create a project info file, establish an input layer directory, an output layer directory and an incremental layer directory under the project directory, and set up hierarchical info files to form an initial directory structure; The node dependency building module is used to create node info files and out subdirectories for hierarchical nodes within the input layer, progressive layer and output layer defined by the initial directory structure, forming a neural network-like node dependency structure. The progressive processing module is used to build script files for the script subdirectories of each progressive layer node and output layer node in the neural network node dependency structure. It takes the output of the dependent node as input and combines the needs of the node to generate output to the out subdirectory, forming input layer nodes, progressive layer nodes, output layer nodes and the dependency relationships between nodes. The change propagation module is used to construct a project overview network diagram based on input layer nodes, progressive layer nodes, output layer nodes, and the dependencies between nodes. It locates change nodes and change levels in the project overview network diagram and marks them with colors. It propagates the impact of changes layer by layer along the dependency path to obtain a consistent hierarchical dependency structure and the out directory content of the output layer nodes. The release build module is used to aggregate, verify, and build the output layer source code and configuration based on the consistent hierarchical dependency structure and the contents of the output layer node out directory, and generate a software release package.

[0064] In summary, this invention organizes the application software development process into a hierarchical node structure similar to a neural network. When a node changes, it automatically identifies the location and impact level of the change using a project overview network diagram. The change is then propagated layer by layer along the dependency path to form a consistent hierarchical dependency structure. This allows software modifications to be accurately perceived, automatically linked, and consistently updated, effectively avoiding missed updates and ineffective refactoring. This improves the iterative controllability, structural consistency, and reliability of final delivery in the application software development process.

[0065] It should be noted that the above embodiments are only used to illustrate the technical solutions of the present invention and are not intended to limit it. Although the present invention has been described in detail with reference to preferred embodiments, those skilled in the art should understand that modifications or equivalent substitutions can be made to the technical solutions of the present invention without departing from the spirit and scope of the technical solutions of the present invention, and all such modifications or substitutions should be covered within the scope of the claims of the present invention.

Claims

1. A method for software progressive evolution based on neural networks, characterized in that, include: Create a project, and within the project, create an input layer, an output layer, and an incremental layer to form the initial structure; Within the input layer, progressive layer, and output layer defined by the initial structure, hierarchical nodes are established to form a neural network-like node-dependent structure; In a neural network-style node dependency structure, scripts are built for each progressive layer node and output layer node. The output of the dependent node is used as input, and the output content is generated in combination with the needs of the node to produce a software distribution package.

2. The neural network-based software progressive development method of claim 1, wherein, The establishment of a project refers to naming the project with a project name and saving the basic project information as structured content through structured processing.

3. The neural network-based software progressive development method of claim 1, wherein, The specific steps for establishing an input layer, output layer, and progressive layer under the project to form the initial structure are as follows: Establish a lower-level structure under the project, and agree that Input is the input layer and Output is the output layer, and agree that the sequence number is used to name each progressive layer; The basic information of the corresponding layer is saved in the input layer, output layer and each progressive layer, and together with the project, they form the initial structure.

4. The neural network-based software progressive development method of claim 1, wherein, Within the initial structure's defined input, progressive, and output layers, hierarchical nodes are established to form a neural network-like node-dependent structure. The specific steps are as follows: Within the input layer defined by the initial structure, the node division is determined according to each requirement point; In the initial directory structure, the progressive layer and the output layer are locked as the processing scope. First, the progressive layer is sorted according to its hierarchical order, and finally the output layer is added. Based on the principle of software abstraction hierarchy progression, hierarchical carrying nodes are set for each sorted directory. Based on the progressive dependency chain, each level of node stores node descriptions and information about the set of dependent nodes, forming a neural network-like node dependency structure.

5. The software incremental development method based on neural networks as described in claim 1, characterized in that, The process of constructing scripts for each progressive layer node and output layer node in a neural network node dependency structure, using the output of the dependent node as input and combining it with the needs of the current node, to generate the output content, is as follows: In a neural network-based node dependency structure, progressive layer nodes and output layer nodes are identified as script configuration objects, and the input source of each node's processing script is determined based on the set of dependent nodes recorded in the node information. The processing scripts of the progressive layer nodes and the output layer nodes read the output content from the dependent nodes, combine it with the needs of the current node to form the output content of the current node and save it, thus forming the input layer nodes, progressive layer nodes, output layer nodes and the dependencies between the nodes. Based on the input layer nodes, progressive layer nodes, output layer nodes, and the dependencies between nodes, construct a project overview network diagram according to the progressive dependency chain. In the project overview network diagram, the current input layer nodes, progressive layer nodes, output layer nodes, and the dependencies between nodes are compared with the previous version's input layer nodes, progressive layer nodes, output layer nodes, and the dependencies between nodes to identify the nodes whose output content has changed, obtain the changed nodes, and determine the changed level based on the hierarchical position of the changed nodes in the project overview network diagram. In the project overview network diagram, apply a first preset color mark to the changed nodes and a second preset color mark to the changed levels; The changed node is identified as the starting node for the propagation of the change's impact based on the color markings. Then, starting from the starting node, downstream nodes are searched along the dependency directions represented by the directed lines in the project overview network diagram. The propagation is carried out layer by layer down the dependency path, with downstream nodes as the propagation objects. The affected downstream nodes and their corresponding levels are associated and marked to form a consistent hierarchical dependency structure. The script is then executed on the output layer nodes in the consistent hierarchical dependency structure to obtain the output content of the output layer nodes.

6. The software incremental development method based on neural networks as described in claim 1, characterized in that, The specific steps for generating the software distribution package are as follows: Based on a consistent hierarchical dependency structure, the output layer node is determined as the publishing target, and the set of output layer content is obtained from the output layer node; The output layer content set is validated, and after the validation passes, the corresponding build script is called according to the preset build rules of the output layer node to compile the output layer source code and package the configuration file together to generate a software distribution package.

7. A software incremental development system based on neural networks, based on the software incremental development method based on neural networks according to any one of claims 1 to 6, characterized in that, include: The project architecture initialization module is used to create the project, and to create an input layer, an output layer, and a progressive layer under the project to form the initial directory structure; The node dependency structure building module is used to establish hierarchical nodes within the input layer, progressive layer, and output layer defined by the initial directory structure, forming a neural network-like node dependency structure. The script execution build and release module is used to build scripts for each progressive layer node and output layer node in a neural network node dependency structure. It takes the output of the dependent node as input and combines it with the needs of the node to generate output content and produce a software release package.

Images