A big data-based software development management method

Abstract

The application discloses a software development management method based on big data, relates to the technical field of software development management, and comprises the following steps: collecting multi-source development data, transmitting the multi-source development data to a data lake in real time through a distributed message queue, generating time-stamped structured data flow and a time sequence relationship graph, performing Monte Carlo sampling on a neural radiation field three-dimensional radiation field model and a causal influence graph, simulating the cascading influence of a current code submission, outputting a risk value and a dependency chain, loading the neural radiation field three-dimensional code space model, the node risk value and the dependency chain, dynamically rendering a causal influence path, and generating a visual risk report, generating a code optimization task according to the visual risk report, submitting an optimized code version to a code library, and calibrating the parameters of the neural radiation field three-dimensional code space model. The application can analyze the space-time characteristics of code changes, combine Monte Carlo simulation, identify implicit dependencies and risk transmission chains, and improve the comprehensiveness and prediction ability of architecture corruption analysis.

Description

TECHNICAL FIELD

[0001] The present application relates to the technical field of software development management, and particularly relates to a software development management method based on big data. BACKGROUND

[0002] With the rapid development of information technology, software systems have become the core infrastructure supporting the operation of modern society. The complexity of the software development process, the dependence of multi-team collaboration and the rapid iteration of industry demand make efficient and intelligent software development management methods the key elements to ensure project success. Especially in large distributed systems, continuous integration and delivery scenarios, accurate assessment and dynamic optimization of code quality, architecture health and team collaboration efficiency are particularly important.

[0003] Traditional software development management methods mainly rely on manual experience judgment, static code analysis tools and discrete index monitoring systems. These methods often have response lags, local optimizations and inaccurate predictions when faced with massive multi-source development data, dynamically evolving code bases and complex causal dependency relationships. In particular, in key scenarios such as code smell propagation path identification, architecture corruption trend prediction and risk cascade effect analysis, traditional methods are difficult to effectively integrate spatiotemporal features, lack modeling capabilities for nonlinear correlations and implicit dependencies, resulting in a lack of forward-looking and systematic quality control measures. SUMMARY

[0004] In view of the above existing problems, the present application is proposed.

[0005] Therefore, the present application provides a software development management method based on big data to solve the problem that traditional methods are difficult to effectively integrate spatiotemporal features and lack modeling capabilities for nonlinear correlations and implicit dependencies.

[0006] To solve the above technical problems, the present application provides the following technical solutions:

[0007] In a first aspect, the present application provides a big data-based software development management method, which comprises: collecting multi-source development data, transmitting the multi-source development data to a data lake in real time through a distributed message queue, generating time-stamped structured data stream and time sequence relationship graph; constructing a neural radiation field three-dimensional code space model based on the structured data stream, synchronously mapping coupling strength, code modification frequency and developer collaboration density of the code, representing code smell concentration through voxel density, and outputting a dynamically updated neural radiation field three-dimensional radiation field model; extracting a code change event chain from the time sequence relationship graph, calculating a causal strength weight based on the product of the probability of a historical change causing a defect and the repair man-hours, and constructing a causal influence graph with a risk propagation path; performing Monte Carlo sampling on the neural radiation field three-dimensional radiation field model and the causal influence graph, simulating cascading influence of a current code submission, and outputting a risk value and a dependency chain; loading the neural radiation field three-dimensional code space model, the node risk value and the dependency chain, dynamically rendering a causal influence path, and generating a visual risk report; generating a code optimization task according to the visual risk report, submitting an optimized code version to a code repository, and calibrating parameters of the neural radiation field three-dimensional code space model.

[0008] As a preferred scheme of the big data-based software development management method, the multi-source development data types are defined as code submission records, defect reports and developer collaboration logs.

[0009] As a preferred scheme of the big data-based software development management method, the step of outputting the dynamically updated neural radiation field three-dimensional radiation field model comprises the following steps:

[0010] The Avro records in the data lake are parsed to extract code file paths, code modification frequencies, developer collaboration densities and coupling strengths.

[0011] The code file paths are taken as code entity space coordinates, the code repository space is discretized into a voxel grid, and the voxel resolution is matched with the code level granularity.

[0012] Based on the voxel grid space structure, a multi-layer perception mechanism is used to construct a neural radiation field continuous function, the voxel coordinates are input, the coupling strength features of the code entities are propagated through a graph convolution network, and the feature vectors of the adjacent voxels are updated. The function outputs the optimized density values and the feature vectors. The function outputs the optimized density values and the feature vectors.

[0013] The calling relationship graph between the code entities is taken as input, a weighted edge is established between the corresponding voxels, the coupling strength features of the code entities are propagated through a graph convolution network, and the feature vectors of the adjacent voxels are updated.

[0014] Based on the density values and the feature vectors, the smell concentration is defined, the MLP parameters are optimized through a mean square error loss, the incremental training is triggered by monitoring changes in the structured data stream, and the updated neural radiation field three-dimensional radiation field model is output.

[0015] As a preferred solution of the software development management method based on big data, the method comprises the following steps:

[0016] Extracting the change events of the code entity from the commit history, and generating an event sequence set according to the timestamp;

[0017] Taking the code entity as a node, establishing a directed edge, and forming a time-constrained time sequence graph;

[0018] Based on the association between the defect report and the code change, the probability of the change event causing the defect is calculated using the Bayes theorem;

[0019] The average repair man-hour data of each defect is calculated, and the weighted average repair man-hour of the change event associated with multiple defects is calculated to form a causal influence graph.

[0020] As a preferred solution of the software development management method based on big data, the method comprises the following steps:

[0021] As a preferred solution of the software development management method based on big data, the method comprises the following steps:

[0022] As a preferred solution of the software development management method based on big data, the method comprises the following steps:

[0023] As a preferred solution of the software development management method based on big data, the method comprises the following steps:

[0024] In a second aspect, the present application provides a computer device comprising a memory and a processor, wherein the memory stores a computer program, and wherein the computer program is executed by the processor to implement any step of the software development management method based on big data according to the first aspect of the present application.

[0025] In a third aspect, the present application provides a computer readable storage medium having stored thereon a computer program, wherein the computer program, when executed by a processor, implements any step of the big data-based software development management method according to the first aspect of the present application.

[0026] The present application has the following beneficial effects: by combining multi-dimensional development data such as code modification frequency, developer collaboration density and architecture coupling strength with three-dimensional modeling of neural radiation field and causal influence graph analysis, real-time monitoring and accurate prediction of dynamic distribution of code odor and risk propagation path are realized; by extracting the spatio-temporal correlation characteristics of code changes and constructing a dynamic simulation mechanism that integrates Monte Carlo sampling, implicit dependency relationships and cascading risk transmission chains are effectively identified, and the comprehensiveness and prediction ability of architecture corruption trend analysis are improved; at the same time, based on three-dimensional code space model and risk path visualization mapping, a closed-loop feedback of development task optimization and dynamic calibration of model parameters is established, and the initiative and systematicness of quality control measures are enhanced, thereby reducing the accumulation of technical debt while improving development collaboration efficiency. BRIEF DESCRIPTION OF DRAWINGS

[0027] In order to more clearly illustrate the technical solutions of the embodiments of the present application, the following will briefly introduce the drawings needed to be used in the embodiment description. Obviously, the drawings in the following description are only some embodiments of the present application, and other drawings can be obtained by those skilled in the art without creative labor.

[0028] Fig. 1 The flowchart of the big data-based software development management method.

[0029] Fig. 2 The flowchart of the neural radiation field model construction.

[0030] Fig. 3 The flowchart of the causal influence graph generation.

[0031] Fig. 4 The flowchart of the Monte Carlo risk simulation. DETAILED DESCRIPTION

[0032] In order to make the above-mentioned purposes, features and advantages of the present application more apparent and easy to understand, the specific embodiments of the present application will be described in detail below with reference to the drawings of the specification.

[0033] In the following description, many specific details are set forth in order to provide a thorough understanding of the present application, but the present application can also be implemented in other ways different from those described herein, and those skilled in the art can make similar generalizations without departing from the connotation of the present application, therefore the present application is not limited to the specific embodiments disclosed below.

[0034] Second, the "one embodiment" or "an embodiment" referred to herein means a specific feature, structure, characteristic, or combination of features and / or characteristics described herein that can be included in at least one implementation of the present application. The various appearances of "in one embodiment" or "an embodiment" in the specification do not all refer to the same embodiment, although they can.

[0035] Referring to Figs. 1-4 For one embodiment of the present application, the embodiment provides a big data-based software development management method, comprising the following steps:

[0036] S1: Collecting multi-source development data, transmitting to a data lake in real time through a distributed message queue, generating time-stamped structured data stream and time sequence relationship graph.

[0037] Specifically, the following steps are included:

[0038] S1.1: Defining multi-source development data types as code commit records, defect reports and developer collaboration logs, unified in JSON format, fields including code file path, committer ID, timestamp, modified line number, defect ID, repair status, collaboration session ID.

[0039] S1.2: Deploying a collection agent, the agent listens to events and pushes them to a specified Topic of a distributed message queue in real time.

[0040] Wherein, Topic represents the category label of the message.

[0041] Specifically, a hook script is configured in the control server, which is automatically triggered when the developer performs git commit or svn commit operation, further capturing the submitter mailbox, changed file list, submission timestamp, etc. Similar to installing an automatic recorder at the entrance of the code base, every time someone "moves the code", an electronic account is generated;

[0042] A customized plug-in is installed in the Jira, ZenTao and other defect tracking systems, which obtains the change details by listening to the ticket state machine (such as from "to be processed" to "repaired").

[0043] For example, when the tester clicks the "solve defect" button, the plug-in will immediately capture the associated code branch, responsible person, priority change record, which is equivalent to installing an event sensor on the defect board.

[0044] A background service is deployed in the collaboration platform, which subscribes to group message events through an open platform API. The background service continuously listens to the @ mention, file upload, task assignment and other key actions of the specified channel, and extracts important discussion points in real time.

[0045] Real-time important discussion points are extracted and pushed to the message queue corresponding to the topic. The message queue assigns topics according to data sources, sets partition strategies to ensure transmission order, and enables data compression to reduce bandwidth occupation. Verify the connectivity of the agent to the message queue, check the data integrity, and if abnormal data is found, record and alarm.

[0046] The Topic is divided by timestamp partitioning, the number of partitions is consistent with the number of data source instances, the message retention time is set, compression and deduplication are enabled to ensure data order and integrity.

[0047] S1.3: Store raw data in MinIO object storage using data lake, consume distributed message queue through Flink stream processing, parse JSON fields and standardize them into Avro records with UTC timestamp (i.e. timestamped structured data stream), discard invalid data, and output to data lake.

[0048] Specifically, after creating a storage bucket path in MinIO that is layered by data source type and time, deploying a Flink stream processing job to connect to the message queue and configure a JSON deserializer, the job implements field parsing logic to extract valid data and supplement UTC timestamps to eliminate multi-time zone differences. On this basis, define an Avro Schema to format the parsed structured data - this Schema serves as a data contract, clearly defining field types (e.g. timestamp as long, code line number as int), which not only solves the ambiguity problem caused by JSON dynamic types, but also improves storage efficiency through binary encoding; then set up multi-level filtering rules: intercept records that fail Schema validation (e.g. missing version number, illegal timestamp format, etc.) in real time to ensure only compliant data enters the subsequent process; finally, use a connector to write Avro records that pass verification to the corresponding storage path according to data source type and hourly time partitioning, and establish an automatic comparison mechanism between message queue consumption displacement and storage file records, triggering a retry pipeline when data loss or duplication is detected.

[0049] S1.4: Extract code files, functions, and class entities from structured data streams, aggregate co-modification events by time window, and create nodes and edges in the graph database Neo4j.

[0050] The edge attributes include the first co-occurrence timestamp, co-occurrence frequency, and the latest update timestamp.

[0051] Specifically, starting from extracting code entity features from structured data streams, taking code file path, function signature and class name as entity unique identifier, determining the entity scope affected by each change through parsing the commit records of version control system (such as Git diff information); based on the spatio-temporal correlation of change events, identifying entity pairs with co-modification relationship - that is, files, functions or classes modified simultaneously in the same commit; on this basis, introducing a sliding time window mechanism (such as a 24-hour window), and counting the co-modification frequency between entities within a certain period to quantify their collaboration strength; then constructing a dynamic graph in the Neo4j graph database.

[0052] S2: Based on the structured data stream, a neural radiation field three-dimensional code space model is constructed, the coupling strength, code modification frequency and developer collaboration density of the code are mapped synchronously, the code smell concentration is represented by voxel density, and a dynamically updated neural radiation field three-dimensional radiation field model is output.

[0053] Specifically, the following steps are included:

[0054] S2.1: Parse the Avro records in the data lake, extract the code file path as the code entity spatial coordinate, the code modification frequency and the developer collaboration density as the scalar features, and the coupling strength as the vector feature.

[0055] It should be noted that the code entity spatial coordinate and the dynamic features (scalar features and vector features) are used as input data of the neural radiation field three-dimensional code space model, providing a basis for spatial discretization.

[0056] S2.2: Based on the code entity spatial coordinate, the code repository is discretized into a voxel grid, and the voxel resolution is matched with the code level granularity.

[0057] Each voxel stores an initial density value and a feature vector.

[0058] Specifically, based on the extreme value range of the code entity spatial coordinate, the voxel grid boundary is determined, the resolution is set according to the code level granularity (such as 1.0x1.0x1.0 for file level, 0.2x0.2x0.2 for function level, and 3.0x3.0x3.0 for directory level) to generate a uniform three-dimensional grid, each code entity coordinate is mapped to the corresponding level voxel unit, the density value and the feature vector are initialized for each voxel, the grid is dynamically expanded to handle coordinates beyond the boundary, ensuring that all code entities are completely covered, and providing a structured discrete spatial input for the neural radiation field model.

[0059] S2.3: Based on the voxel grid spatial structure, a multi-layer perception (MLP) is used to construct a neural radiation field continuous function , inputting the voxel coordinate , through function and function output optimized density value and feature vector , the expression is as follows:

[0060] ;

[0061] ;

[0062] ;

[0063] In the formula, represents the three-dimensional space coordinates of the code entity, represents the entire set of trainable parameters of the neural radiation field model, represents the weight matrix of the density prediction layer, represents the bias term of the density prediction layer, represents the weight matrix of the feature prediction layer, represents the bias term of the feature prediction layer;

[0064] S2.4: Taking the call relationship graph between code entities as input, a weighted edge is established between the corresponding voxels (the weight is the number of calls between entities), the coupling strength feature of the code entity is propagated through the graph convolution network, and the adjacent voxel feature vector is updated.

[0065] It should be noted that the adjacent voxel feature vector inherits from the S2.3 output and extends the associated attributes.

[0066] Further, the number of modifications of the voxel associated code entity in the time window is counted, the logarithmic density increment is calculated, and is added to the current voxel density;

[0067] According to the number of independent developers associated with the voxel, the normalized collaboration density is calculated, and the coupling strength, code modification frequency, and developer collaboration density are integrated into the voxel attribute through a dynamic feature mapping process, providing input for the calculation of the smell concentration of the code.

[0068] S2.5: Based on the density value and the feature vector , define the smell concentration , the expression is as follows:

[0069] ;

[0070] In the formula, represents the developer collaboration density;

[0071] When , it is determined as a high-density condition (the code modification frequency of the voxel is in the top 20%); when , it is determined as a low collaboration condition (less than 30% of the developers participate in maintenance).

[0072] Mark high-density and low-collaboration voxels as odor regions, optimize MLP parameters by mean square error loss, listen to structured data stream changes to trigger incremental training, and output updated neural radiation field three-dimensional radiation field model.

[0073] For example: when the voxel density (high frequency of modification of legacy code) and the collaboration density (only 2 people maintain) are further calculated odor concentration , when the odor concentration exceeds the threshold, mark the voxel as a red alert area, and calculate the mean square error loss based on the difference between the true value and the MLP prediction value of the current all voxel density and , update the MLP parameters by back propagation, when 5 new commit records are detected in the code repository, trigger incremental training immediately, recalculate and using the modification frequency and collaboration records in the latest data stream, and output the updated neural radiation field three-dimensional radiation field model.

[0074] It should be noted that the determination of the odor concentration threshold is based on statistical analysis of historical project code repositories, by collecting code modification records and developer collaboration data of multiple projects, calculating the modification frequency and collaboration density distribution characteristics of each module, using clustering analysis method to divide the code modules into different categories, and through the receiver operating characteristic curve analysis to determine the optimal segmentation threshold as the odor concentration determination standard.

[0075] S3: Extract code change event chain from time series relationship graph, calculate causal strength weight based on the product of historical change-induced defect probability and repair man-hours, and construct causal impact graph with risk propagation path.

[0076]

[0077] S3.1: Extract code entity change events from commit history, generate event sequence set by timestamp, expression is:

[0078] ;

[0079] In the formula, denotes the event sequence set, denotes the th change event in the set, is the event index number, which represents the order of the event in time sequence, denotes the total number of events in the set;

[0080] Each change event contains change time, developer, modified code entity and associated defect report ID.

[0081] S3.2: Take code entities as nodes, and establish directed edges between two code entities if they are modified consecutively within a time window, forming a time-constrained temporal relationship graph ; wherein, represents a node set, represents an edge set generated by time-adjacent events in the event sequence set.

[0082] S3.3: Based on the association between defect reports and code changes, use Bayes' theorem to calculate the change event probability of causing defects, expressed as:

[0083] ;

[0084] In the formula, change event weighted probability value of causing defects, represents the change event the number of directly associated defects, represents the change event the total number of modifications corresponding to the code entity, represents the identifier of the defect association scenario, represents the identifier of the baseline modification times, is the timestamp, indicating the current analysis time, represents the occurrence time of the change event , represents the time decay coefficient, which determines the degree of non-linear decay of the time difference on the probability value, ; wherein,

[0085] S3.4: Calculate the average repair man-hour data of each defect, and for the change event associated with multiple defects, calculate the weighted average repair man-hour.

[0086] Specifically, the repair man-hours of all defects associated with the change are summed up, and then divided by the total number of associated changes corresponding to these defects, to obtain the standardized repair man-hour estimate of the change event.

[0087] In the temporal relationship graph, for each directed edge connecting two change events, the causal strength weight is determined by multiplying three factors, and is persisted as a node attribute in the causal impact graph: the first factor is the probability estimate of the starting change event causing defects, the second factor is the standardized repair man-hour of the change event, and the third factor is the binary function result of judging whether the target change event is located on the starting change risk propagation path.

[0088] The calculated causal strength weight is assigned to the corresponding directed edge in the time sequence relationship graph, the overall update of the edge weight of the graph is completed, and a causal influence graph containing risk quantification features is finally formed. Therefore, the risk propagation strength and path between different code changes can be intuitively displayed.

[0089] It should be noted that the node risk value is the weighted sum of the defect probability, the repair cost and the architecture corruption coefficient. The static risk level of a single code entity is evaluated, and the causal strength weight is calculated by the product of the component factors of the node risk value, which quantifies the conduction strength of the risk between entities. Both of them cooperatively support complete risk analysis.

[0090] Specifically, the calculation method of the defect probability is as follows: the correlation between code changes and defect reports is extracted from historical data. The ratio of the number of defects caused by each code entity in historical modifications to the total number of modifications is calculated as the initial defect probability benchmark value. A time decay factor is used to weight the historical defect data, and recent defects are given higher weights. The prior probability and observation data are fused using Bayes' theorem to output a dynamically adjusted defect probability value. This probability value is updated in real time as the code continues to be modified and defects are repaired.

[0091] Furthermore, the repair man-hour records of each defect in the defect tracking system are extracted. For multiple defects associated with the same code entity, the moving average of repair man-hours is calculated to smooth abnormal values. According to the defect severity level, a weight coefficient is set to adjust the basic man-hours. The communication frequency and duration in the developer collaboration log are analyzed to quantify the coordination cost involved in multi-module collaboration. The standardized repair man-hours and collaboration cost are added to obtain the comprehensive repair cost estimate of the code entity.

[0092] It should be noted that the evaluation process of the architecture corruption coefficient is as follows: high-frequency modification but low-collaboration code regions are identified through voxel density analysis. The initial corruption index is calculated by combining the static detection results of code smells. The frequency of violation patterns such as circular dependencies and cross-layer calls in the code dependency graph is analyzed, and the architecture deviation is quantified using graph algorithms. The spatial density features, smell indicators and architecture deviation are normalized and fused, and a corruption coefficient in the range of 0-1 is generated by weighted summation. The coefficient is dynamically updated with code modifications, and high-corruption regions appear as high-density red voxels in the three-dimensional model.

[0093] S4: Monte Carlo sampling of the neural radiation field three-dimensional radiation field model and the causal influence graph to simulate the cascading influence of the current code submission, and output the risk value and dependency chain.

[0094] Wherein, the causal influence path is a sequence of edges generated from the causal influence graph through Monte Carlo sampling.

[0095] S4.1: Extract the voxel density and feature vector from the neural radiation field model, extract the node risk value and edge weight from the causal influence graph, and construct a joint sampling space of three-dimensional code space and causal dependence relationship.

[0096] wherein each sampling point in the sampling space contains a voxel space coordinate, an odor concentration value, and an associated code change event chain, providing an analysis basis for subsequent risk simulation.

[0097] Specifically, load the voxel density distribution and feature parameters generated by the neural radiation field model, synchronously obtain the risk score of each node in the causal influence graph and the influence weight of the connected edge, establish a mapping relationship based on the spatial coordinates of the code entity, integrate the density value, risk feature, associated change record and influence weight into a unified joint sampling space, and form a complete analysis basis containing spatial distribution and logical dependence relationship.

[0098] S4.2: Initialize the key parameters of Monte Carlo sampling, including the total sampling number, the maximum depth limit of a single path, and the sampling space range. Bind the coordinates of the current submitted code entity as the initial sampling point.

[0099] S4.3: Based on the random walk algorithm, starting from the initial sampling point, select adjacent voxels according to the probability distribution of voxel density, and select dependence chain branches according to the edge weight of the causal influence graph, and iteratively generate a number of simulated paths of code change influence.

[0100] Specifically, after determining the path starting point based on the voxel coordinates of the current submission code in the initialization stage, through a dynamic balance of the double-criterion decision mechanism of voxel density gradient and causal edge weight, the selection probability of spatial adjacent voxels and the transfer weight of logical dependence edges are calculated simultaneously at each path extension, and an adaptive normalization fusion algorithm is used to generate a mixed probability matrix to guide the next jump direction. The spatial density decay factor and the causal weight accumulation coefficient of the path nodes are updated in real time during the iteration process, and the current path generation is terminated when the preset path depth is reached or the low-density region is entered, and finally a set of code change influence paths containing three-dimensional spatial distribution characteristics and cross-version logical dependence relationships are output.

[0101] Preferably, by combining the spatial distribution of code modification heat and the dependence relationship of historical changes, a path generation mechanism that dynamically balances the two weights is used to analyze the activity level and logical influence transmission characteristics of the code region during the simulation process. Compared with existing technologies that only use call graph analysis or defect history statistics, this method can discover cross-module associated risks that are missed based on static call relationship analysis, as well as cross-version influence chains that are difficult to identify based on version history records alone. By continuously tracking the state changes during the code modification process, a more comprehensive analysis perspective is provided for quality control of complex software, improving the pertinence and timeliness of maintenance work.

[0102] For example, when the modification of the core payment function triggers the analysis, starting from its hot zone location in the code space, considering the modification activity and historical dependency strength of the surrounding modules, the most relevant order processing module is selected as the first hop, and during the extension process, the spatial aggregation degree and logical dependency of each module are evaluated synchronously, and when a low-activity auxiliary function module is detected, the path expansion is terminated, and the final generated transmission chain clearly shows the complete influence path from the core function to the surrounding modules.

[0103] Statistical analysis is performed on all the simulated risk propagation paths. The comprehensive risk indicators of each node on each path are calculated, and the standardized evaluation results are obtained by comparing the path length and the total risk value. The key propagation paths with the highest frequency are screened, and the overall risk expectation level of the system is calculated.

[0104] S4.4: Map the high-risk propagation paths obtained by analysis back to the three-dimensional code space, and superimpose and fuse with the density distribution data of the neural radiation field, output the visualization results including interactive three-dimensional risk distribution map and structured analysis report, and intuitively display the spatial distribution and logical association of key risk paths.

[0105] S5: Load the neural radiation field three-dimensional code space model, risk value and dependency chain, dynamically render the causal influence path, and generate a visual risk report.

[0106] wherein the causal influence subgraph is a neighborhood subgraph obtained from the causal influence path extension.

[0107] Specifically, the following steps are included:

[0108] S5.1: Based on the three-dimensional code space coordinates and risk value distribution matrix output by the neural radiation field model, generate a dynamic rendering scene basic framework; map the nodes of the causal influence path to space heat spheres (the radius corresponds to the risk value size, and the color mapping is the odor concentration gradient), and map the edge weight to the transparency (the higher the weight, the less transparent) and the thickness parameters (the weight is positively correlated with the pipe diameter) of the connecting pipe, to complete the scene parameter initialization.

[0109] S5.2: When the user selects a space heat sphere or a connecting pipe, automatically trigger the path highlighting of the high-weight dependency chain according to the pipe transparency parameter, synchronously call the causal influence subgraph generation module, filter the associated change event chain based on the pipe thickness parameter of the currently selected area, and display the code odor concentration gradient cloud map and the developer collaboration relationship topology net in real time.

[0110] S5.3: According to the pipe transparency and thickness parameters of the highlighted path, extract the historical defect rate and modification record of the corresponding code module, and automatically generate a visual risk report including primary directory, secondary directory and tertiary directory.

[0111] Specifically, the first-level directory is risk level; the second-level directory is key dependency chain details; and the third-level directory is a list of recommended refactoring modules, supporting direct jump to the corresponding pipeline visualization in the three-dimensional scene by clicking the dependency chain entry.

[0112] For example, when a user selects a thick pipeline (corresponding to the calling chain of the payment module and the order module) with high transparency (weight = 0.8) in the three-dimensional scene, a hierarchical risk report is automatically generated based on the historical data of the two modules (the defect rate of the payment module is 12% in the past half year, and the defect rate of the order module is 8%): the first-level directory shows "high risk" (because the combined defect rate exceeds the threshold of 10%), the second-level directory expands the detailed calling path of the dependency chain (payment module→order processing function→logistics interface, with a total calling number of 53), and the third-level directory lists the core function of the payment module recommended for refactoring (marked as "payment amount verification function" because of the highest historical defect rate). Clicking the entry automatically locates the corresponding red highlighted pipeline in the three-dimensional scene, and simultaneously displays the collaboration developer density cloud and the recent modification record heat map around the function.

[0113] S6: According to the visual risk report, generate a code optimization task, submit the optimized code version to the code repository, and calibrate the parameters of the neural radiation field three-dimensional code space model.

[0114] Specifically, the following steps are included:

[0115] S6.1: Analyze the list of recommended refactoring modules in the visual risk report, and generate a priority-ordered optimization task queue based on the historical task processing efficiency of the developers (median task response time, success rate) and the current number of pending tasks, wherein the high-priority tasks are automatically associated with the dependency chain modules with the thickest and lowest transparency in the three-dimensional scene.

[0116] After the developers complete the optimization code and submit it to the version library, the density parameters and edge weight coefficients of the corresponding voxels in the neural radiation field model are updated according to the list of recommended refactoring modules actually completed in the task queue, so as to realize dynamic co-calibration of the three-dimensional code space model and the risk analysis results.

[0117] It should be noted that the current number of pending tasks refers to the total number of tasks that have not been completed and are in an active state, including ongoing development tasks, pending defects, and code review items.

[0118] The embodiment also provides a computer device suitable for the case of the software development management method based on big data, which comprises a memory and a processor; the memory is used to store computer executable instructions, and the processor is used to execute the computer executable instructions to realize the software development management method based on big data proposed in the above embodiment.

[0119] The computer device can be a terminal, which includes a processor, a memory, a communication interface, a display screen and an input device connected by a system bus. The processor of the computer device is configured to provide computing and control capabilities. The memory of the computer device includes a non-volatile storage medium and an internal memory. The non-volatile storage medium stores an operating system and a computer program. The internal memory provides an environment for running the operating system and the computer program in the non-volatile storage medium. The communication interface of the computer device is configured to perform wired or wireless communication with an external terminal. The wireless communication can be achieved by WIFI, a carrier network, NFC (Near Field Communication) or other technologies. The display screen of the computer device can be a liquid crystal display screen or an electronic ink display screen. The input device of the computer device can be a touch layer overlaid on the display screen, or a key, a trackball or a touchpad arranged on the shell of the computer device, or an external keyboard, a touchpad or a mouse, etc.

[0120] The embodiment also provides a storage medium having a computer program stored thereon, the program being executed by a processor to implement the method for managing software development based on big data according to the above embodiment. The storage medium can be implemented by any type of volatile or non-volatile storage device or a combination thereof, such as a static random access memory (SRAM), an electrically erasable programmable read-only memory (EEPROM), an erasable programmable read-only memory (EPROM), a programmable read-only memory (PROM), a read-only memory (ROM), a magnetic memory, a flash memory, a magnetic disk or an optical disk.

[0121] In summary, the application realizes real-time monitoring and accurate prediction of dynamic distribution of code smell and risk propagation path by combining code modification frequency, developer collaboration density and architecture coupling strength with neural radiation field three-dimensional modeling and causal influence graph analysis; by extracting the spatio-temporal correlation characteristics of code changes and constructing a dynamic simulation mechanism that integrates Monte Carlo sampling, it effectively identifies implicit dependency relationships and cascading risk transmission chains, improving the comprehensiveness and prediction ability of architecture corruption trend analysis; at the same time, based on the three-dimensional code space model and risk path visualization mapping, a closed-loop feedback of development task optimization and dynamic calibration of model parameters is established, enhancing the initiative and systematicness of quality control measures, thereby reducing the accumulation of technical debt while improving development collaboration efficiency.

[0122] It should be noted that the above embodiments are only used to illustrate the technical solutions of the present application and not to limit it. Although the present application has been described in detail with reference to the preferred embodiments, it should be understood by those skilled in the art that the technical solutions of the present application can be modified or replaced equivalently without departing from the spirit and scope of the technical solutions of the present application, which should be covered in the scope of the claims of the present application.

Claims

1. A big data-based software development management method, characterized in that: The application relates to a code smell prediction method based on neural radiation field and Monte Carlo sampling. Collecting multi-source development data, transmitting the data to a data lake in real time through a distributed message queue, generating a time-stamped structured data stream and a time sequence relationship graph, and constructing a neural radiation field three-dimensional code space model based on the structured data stream, synchronously mapping coupling strength, code modification frequency and developer collaboration density, representing code smell concentration through voxel density, and outputting a dynamically updated neural radiation field three-dimensional radiation field model. Analyzing Avro records in the data lake, extracting code file paths, code modification frequency, developer collaboration density and coupling strength; Discretizing the code repository space into a voxel grid by taking the code file path as the code entity space coordinate, matching the voxel resolution with the code level granularity; Taking the calling relationship graph between code entities as input, establishing a weighted edge between corresponding voxels, propagating the coupling strength features of the code entities through a graph convolution network, and updating the adjacent voxel feature vectors; Based on the voxel grid space structure, a multi-layer perception mechanism is used to build a neural radiation field continuous function, input voxel coordinates, and output optimized density values and feature vectors through function and function output optimized density values and feature vectors; Defining the smell concentration based on the density value and the feature vector, optimizing the MLP parameters through mean square error loss, triggering incremental training by listening to the changes of the structured data stream, and outputting the updated neural radiation field three-dimensional radiation field model; Extracting a code change event chain from the time sequence relationship graph, calculating the causal strength weight based on the product of the probability of a historical change causing a defect and the repair man-hours, and constructing a causal influence graph with a risk propagation path; Monte Carlo sampling of the neural radiation field three-dimensional radiation field model and the causal influence graph, simulating the cascading influence of the current code submission, and outputting the risk value and the dependency chain; Loading the neural radiation field three-dimensional code space model, the node risk value and the dependency chain, dynamically rendering the causal influence path, and generating a visual risk report; According to the visual risk report, a code optimization task is generated, and the optimized code version is submitted to the code library and the neural radiation field three-dimensional code space model parameters are calibrated. The types of multi-source development data are defined as code submission records, defect reports and developer collaboration logs.

2. The big data based software development management method of claim 1, wherein: The construction of the causal influence graph with a risk propagation path includes, 3.The big data based software development management method of claim 1, wherein: Extracting the change events of the code entity from the submission history, generating an event sequence set according to the timestamp; Taking the code entity as a node, establishing a directed edge, and forming a time sequence relationship graph with time constraints; Based on the association between the defect report and the code change, the probability of a change event causing a defect is calculated using the Bayes theorem; Calculate the average repair man-hours data of each defect, and for the change event associated with multiple defects, calculate the weighted average repair man-hours to form a causal influence graph. The Monte Carlo sampling includes superimposing and analyzing the neural radiation field three-dimensional radiation field model and the causal influence graph, simulating the cascading influence of the current code submission, and outputting the risk value and the dependency chain. 4.The big data based software development management method of claim 1, wherein: The dynamic rendering of the causal influence path includes marking the area with a voxel density higher than a critical value as a high-risk hotspot in the neural radiation field three-dimensional code space model, and when a selection action on the high-risk hotspot area is detected, the causal influence subgraph is expanded and a visual risk report is generated. 5.The big data based software development management method of claim 1, wherein: The risk value is the weighted sum of the defect probability, the repair cost and the architecture corruption coefficient. 6.The big data based software development management method of claim 1, wherein: ​ 7.The big data based software development management method of claim 5, wherein: The causal influence path is an edge sequence generated from the causal influence graph by Monte Carlo sampling, and the causal influence subgraph is a neighborhood subgraph extended from the causal influence path.

8. A computer device comprising a memory and a processor, the memory storing a computer program, characterized in that: The processor implements the steps of the big data-based software development management method according to any one of claims 1-7 when executing the computer program.

9. A computer readable storage medium having stored thereon a computer program, characterized in that: The processor implements the steps of the big data-based software development management method according to any one of claims 1-7 when executing the computer program.

Images