A software development intelligent optimization method based on user behavior data feedback

Abstract

The application discloses a kind of software development intelligent optimization methods based on user behavior data feedback, and the application relates to computer software engineering and artificial intelligence technical field, full-link behavior data acquisition and pretreatment: in client and server deployment non-invasive burying point probe, the operation behavior sequence of real-time acquisition user, stay duration, interaction frequency and corresponding server interface response data, the data collected are washed, denoised and conversation aggregation, construct user behavior time sequence atlas, behavior-code mapping model construction: obtain the source code of software system, parse and generate abstract syntax tree and static control flow graph, the application is in: it has built the real feedback closed loop of " user-code ": unlike prior art only focus on the test of code internal logic, the application will " user behavior data " as core driving force, ensure that the direction of optimization is the pain point that user most perceives, realizes truly user-centered software development.

Description

Technical Field

[0001] This invention relates to the fields of computer software engineering and artificial intelligence technology, specifically to an intelligent optimization method for software development based on user behavior data feedback. Background Technology

[0002] With the deep development of mobile internet and enterprise digitalization, software systems are becoming increasingly large in scale and complex in logic. In the traditional software development lifecycle (SDLC), there is often a clear separation between software development and operation. Typically, developers launch the software after completing code writing and functional testing, and subsequent optimization work mainly relies on user complaints, work order feedback, or manual monitoring by operation and maintenance personnel.

[0003] This traditional software maintenance model has significant time lags: First, the time from when users perceive performance bottlenecks (such as page lag or cumbersome operations) to when developers receive feedback often takes weeks or even months; second, when faced with massive amounts of online logs, developers find it difficult to accurately correlate "user behavior" with "underlying code modules," resulting in unclear optimization directions and a tendency to "treat the symptoms rather than the root cause."

[0004] In the prior art, in order to improve the quality of software development, some code analysis-based technologies have emerged in the industry. For example, Chinese patent document CN 117009230 B discloses a precise testing method and system based on code coverage evaluation (hereinafter referred to as the prior art document). This technical solution analyzes code changes through incremental, control flow and data flow analysis to determine the scope of impact of the changed code on related functions, modules and files, and generates test cases accordingly. The prior art document has made contributions in terms of "static code analysis" and "test case generation", which can effectively improve the accuracy of testing.

[0005] However, the prior art and similar existing technologies have the following significant technical shortcomings: 1. Lack of a real feedback loop: The comparison file focuses on the "testing" stage after code changes. Its input source is "the developer's code changes" rather than "the user's actual usage behavior". This means that the technology can only guarantee the logical correctness of the modified code, but cannot tell the developer "where users need to optimize the most" or "which code has the worst experience in high-concurrency scenarios".

[0006] 2. Limited Optimization Focus: Existing technologies often focus on functional correctness or single performance metrics (such as CPU utilization), lacking the comprehensive analytical capabilities to combine user journey with call graph, thus failing to identify experience issues caused by unreasonable business logic design.

[0007] 3. Limited level of automation: Although existing technologies can automatically generate test cases, manual intervention is still required to refactor the code or adjust the configuration after a problem is discovered, failing to achieve a fully automated closed loop from "discovering the problem" to "proposing and implementing optimization suggestions".

[0008] Therefore, there is an urgent need for a closed-loop method that can collect user behavior data in real time, map it to specific code logic through intelligent analysis, and automatically generate optimization suggestions or adjust configurations to solve the problems of slow response and difficulty in locating issues in traditional software maintenance. Summary of the Invention

[0009] The purpose of this invention is to provide an intelligent optimization method for software development based on user behavior data feedback, which aims to overcome the shortcomings of existing technologies such as software maintenance relying on manual feedback, long response cycles, and inability to perform targeted code optimization based on real user behavior.

[0010] To achieve the above objectives, the present invention provides the following technical solution: A software development intelligent optimization method based on user behavior data feedback, comprising the following steps: S1. Full-link behavioral data collection and preprocessing: Deploy non-intrusive tracking probes on the client and server sides to collect user operation behavior sequences, dwell time, interaction frequency and corresponding server interface response data in real time; The collected data is cleaned, denoised, and session aggregated to construct a time-series graph of user behavior.

[0011] S2. Behavior-Code Mapping Model Construction: Obtain the source code of the software system, parse it to generate an Abstract Syntax Tree (AST) and a Static Control Flow Graph (CFG). By combining runtime dynamic call chain tracing data, a multi-dimensional mapping relationship library is established between user interface elements, business operation events, and backend code classes, methods, and database query statements.

[0012] S3. Intelligent Bottleneck Mining and Attribution Analysis: Based on user behavior time series graphs, use graph neural networks (GNNs) to mine high-frequency and inefficient behavior patterns (such as repeated clicks, abnormal backtracking, and long waiting times). By querying the multidimensional mapping relationship library, the inefficient behavior pattern can be traced back to at least one of the specific code snippets, configuration parameters, and database indexes, and a problem diagnosis report can be generated.

[0013] S4. Adaptive optimization strategy generation and closed-loop verification: Input the problem diagnosis report and the associated code context into the pre-trained large code optimization model (LLM) to generate code refactoring suggestion patches and / or dynamic configuration adjustment instructions; If generated patches or instructions are automatically deployed and A / B tested in a sandbox environment, the optimization scheme will be merged into the main branch and selectively applied to the production environment according to the configuration.

[0014] Furthermore, in step S2, the specific process of establishing the multidimensional mapping relationship library includes: using bytecode enhancement technology to inject a trace ID at the server-side method entry and exit points, which is transparently associated with the session ID in the client request header; By analyzing call stack snapshots, the complete function call chain triggered by each type of user behavior and its resource consumption weight can be determined.

[0015] Furthermore, in step S4, the generated optimization strategies include, but are not limited to: caching strategy injection for high-frequency repetitive calculation methods, index addition suggestions for slow query statements, resource degradation configuration for low-frequency functions, and simplified UI interaction flow code for redundant user operation paths.

[0016] Compared with the prior art, the present invention has the following beneficial effects: 1. A real feedback loop between "user and code" is constructed: Unlike existing technologies that only focus on testing the internal logic of the code, this invention takes "user behavior data" as the core driving force, ensuring that the direction of optimization is the pain points most perceived by users, and realizing true user-centered software development.

[0017] 2. Achieved automated management throughout the entire lifecycle: By combining static code analysis (AST / CFG) with dynamic behavior analysis and introducing a large model generation optimization strategy, this invention establishes a fully automated chain from "requirement perception" to "code location" and then to "optimization implementation," significantly shortening the software maintenance cycle.

[0018] 3. Precise granular positioning: By utilizing a multi-dimensional mapping relational library, vague user complaints (such as "lag") can be precisely located to a specific Java class method or SQL statement, greatly reducing the difficulty of troubleshooting. Attached Figure Description

[0019] Figure 1 This is a schematic diagram of the overall process provided for an embodiment of the present invention; Figure 2 This is a schematic diagram illustrating the principle structure of the behavior-code mapping model construction in an embodiment of the present invention; Figure 3 This is a logical block diagram of intelligent bottleneck mining and attribution analysis in an embodiment of the present invention; Figure 4This is an architecture diagram of an AIGC-based optimization strategy generation and verification system provided in an embodiment of the present invention. Detailed Implementation

[0020] The technical solutions of the present invention will be clearly and completely described below with reference to the accompanying drawings of the embodiments of the present invention. Obviously, the described embodiments are only some embodiments of the present invention, and not all embodiments. All other embodiments obtained by those skilled in the art based on the embodiments of the present invention without creative effort are within the scope of protection of the present invention.

[0021] Example 1 This embodiment focuses on the overall system architecture and core processing flow of the method described in this invention, especially the specific implementation in processing massive user behavior data and complex code logic mapping.

[0022] See Figure 1 This embodiment provides a software development intelligent optimization method based on user behavior data feedback. Its execution entity can be a comprehensive DevOps platform that integrates big data processing, static code analysis and artificial intelligence models. The method mainly includes four core parts: data acquisition layer, correlation analysis layer, decision generation layer and execution verification layer.

[0023] Step 1: Full-link behavioral data collection and preprocessing At this stage, the system's goal is to acquire the most detailed possible data on user interactions with the software system.

[0024] 1.1 End-side data collection: The SDK is embedded in the Web and App ends. Unlike traditional statistical tracking, this embodiment adopts full codeless tracking technology. The SDK will automatically intercept all click, scroll, input and navigation events. For each event, the SDK not only records the event type, but also generates a unique element fingerprint through the DOM tree (document object model) path. For example, for a "submit order" button, the system will record its XPath as / html / body / div[2] / form / button, and attach the current page's performance indicators (such as FCP first screen time and TTI interactive time).

[0025] 1.2 Server-side Distributed Trace: On the server side, a distributed tracing system (based on the OpenTelemetry standard) is introduced. Whenever an HTTP request is initiated on the client side, the SDK will inject a globally unique TraceContext into the request header, which contains SessionID and TransactionID. When each microservice node on the server side processes the request, it will parse the Context and write its own processing time, the class name, method name, parameter value, and the exception stack information thrown into the log stream.

[0026] 1.3 Data Cleaning and Aggregation: The massive amount of raw logs collected are transmitted to the real-time computing engine (such as Apache Flink) through the Kafka message queue. The preprocessing module uses the sliding window algorithm to align the discrete end-side events with the server-side trace logs on the timeline using SessionID as the key.

[0027] Noise reduction: Filter out non-natural user behavior data generated by web crawlers and automated test scripts.

[0028] Session segmentation: Divide the user behavior sequence into several logically complete "business operation flows", such as "login -> search for products -> view details -> add to cart".

[0029] Step 2: Building the Behavior-Code Mapping Model This is one of the core innovations of this invention, which aims to solve the deficiency of the lack of business and code association in the existing technology. This step requires the construction of a dynamic "behavior-code knowledge graph".

[0030] 2.1 Static Code Analysis: The system periodically pulls the latest source code from the Git repository, uses code parsing tools (such as Javaparser and ANTLR) to parse the source code, and generates an abstract syntax tree (AST).

[0031] Based on the AST, all class definitions, method definitions, annotation information (such as @Request Mapping(" / order / submit")), and variable dependencies are extracted.

[0032] Constructing a static control flow graph (CFG) and data flow graph (DFG) clarifies the call hierarchy between methods. For example, method A in the Controller layer calls method B in the Service layer, and method B in turn calls method C in the DAO layer. This step is similar to the analysis process in the prior art, but the purpose of this invention is not to calculate test coverage, but to establish the static topology of the code.

[0033] 2.2 Dynamic Mapping Association: The system merges the "business operation flow" collected in step 1 with the "static topology" in step 2.1.

[0034] Entry point matching: By analyzing the URL request path (such as / api / v1 / checkout) in the server logs and using the annotation information extracted from static analysis, the entry point method of the Controller that handles the request can be accurately located.

[0035] Path instantiation: Combining trace data from the tracing network, a specific user click behavior is "illuminated" on the static CFG to show its actual execution path. For example, user A's click triggers Order Controller.create()->Inventory Service.check()->Payment Service.pay().

[0036] Weight calculation: The system calculates the frequency (popularity) and execution time of a certain piece of code triggered by different user behaviors, and marks the "popularity value" and "delay contribution" on the nodes of the code graph.

[0037] Step 3: Intelligent Bottleneck Discovery and Attribution Analysis Based on the above mapping model, the system begins to automatically search for optimization points.

[0038] 3.1 Pattern Recognition: Using sequence mining algorithms (such as PrefixSpan) to find "negative patterns" in user behavior data.

[0039] Mode A (Angry Clicks): The user clicks the same button multiple times in a short period of time, and the server response is slow.

[0040] Pattern B (infinite loop path): The user repeatedly jumps between two pages and eventually exits without achieving the business goal.

[0041] 3.2 Code-level attribution: Once a negative pattern is identified, the system immediately queries the "behavior-code mapping model." For example, for the "angry click" pattern, the system traces back the backend call chain corresponding to the button. The system finds that the InventoryService.check() method triggered by the button executes a full table scan SQL query at the database level, and this query has a delay of up to 2 seconds during peak periods. At this point, the system generates a diagnostic report: Problem: Users click angrily on the checkout page.

[0042] Root cause: The SQL query on line 45 of InventoryService.java lacks an index, causing a response timeout.

[0043] Scope of impact: This issue affected 15% of active users, mainly concentrated during the evening peak hours.

[0044] Step 4: Adaptive optimization strategy generation and closed-loop verification This step introduces AIGC technology to achieve automated repair.

[0045] 4.1 Strategy Generation: Input the above diagnostic report, the relevant InventoryService.java code snippet, and the database schema definition into the fine-tuned Code-LLM.

[0046] The prompt message reads: "You are a senior Java architect who has detected a performance issue caused by slow queries in your code. The table structure is as follows... The code is as follows... Please provide optimization solutions, such as modifying the SQL, adding indexes, or adding Redis caching to the code." Model output: Two methods for large model output: Option 1: Add an index to the sku_id field in the database; Option 2: Use the Spring Cache annotation @Cacheable to cache this method; 4.2 Decision-making and execution: The system's rule engine assesses the risks. Since the risk of adding an index is low, the system automatically generates a database migration script (Flyway Migration Script). At the same time, for Option 2, the system generates a GitPatch (code patch) and adds caching annotations to the methods. 4.3 Closed-loop verification: The system starts the CI / CD pipeline, deploys the generated patch to the "Canary Environment", imports 1% of real user traffic into this environment, and monitors the behavior data of these 1% of users in real time. If the button click response time is found to decrease from 2 seconds to 50 milliseconds and no new error logs are generated, the system determines that the optimization is successful. After successful optimization, the system automatically submits a Pull Request to the code repository, along with a performance comparison report, and notifies the human reviewer to merge the code.

[0047] Through this example, we can see that the entire process, from discovering user dissatisfaction (angry clicks) to code-level fixes, is entirely data-driven, solving the problems of "not knowing user pain points" and "long fix cycles" in traditional development.

[0048] Example 2 This embodiment focuses on the application of the method in a specific scenario: automatic simplification of UI interaction logic based on user confusion behavior. This scenario emphasizes the optimization of front-end code and configuration, further demonstrating the wide applicability of the present invention in full lifecycle management.

[0049] Scene background: Users reported that a certain enterprise-level expense reimbursement software was cumbersome to use, but the development team did not know exactly why it was cumbersome.

[0050] Specific execution steps: S1. Detection of Confusion Behavior The system's data acquisition module detected a large number of users exhibiting behaviors such as "long pauses" and "repeatedly modifying input boxes" on the "Fill in Invoice Details" page. Specifically, after entering the "Invoice Code", users would hover their mouse over the page erratically for more than 10 seconds, then delete the entered content and re-enter it, and the final form submission rate was less than 40%.

[0051] S2. Behavioral Mapping and Thermal Analysis The system maps the DOM structure of the page to the front-end source code (such as React components).

[0052] When the system detects a "long pause", the user's mouse is mainly hovering over the component area called Invoice Code Tooltip.

[0053] Analysis of the front-end logs revealed that the help text within the Tooltip component was overly technical (e.g., displaying database field definitions), making it difficult for users to understand.

[0054] Meanwhile, the system connected to the backend logic and found that users frequently triggered the "invoice verification" interface, which returned the error code "4002: format mismatch".

[0055] S3. Optimization Strategy Generation The system's comprehensive analysis suggests that the root cause of user confusion lies in unclear UI prompts and overly strict validation logic that lacks immediate feedback.

[0056] The system call optimization engine generates the following strategies: Copywriting optimization: Using the NLP model, the technical copy of "database field VARCHAR(20)" is rewritten into plain language "Please enter the 10 or 12 digits in the upper left corner of the invoice".

[0057] Front-end logic adjustment: Generate a JavaScript code patch. It is recommended to add real-time regular expression validation to the front-end input box. When the user enters an incorrect format, a red border and prompt should be displayed directly, instead of waiting for submission to display an error.

[0058] Workflow automation recommendation: The system analysis found that the user uploaded an invoice image, but still needed to manually enter the code. The system recommends enabling the OCR (Optical Character Recognition) function module (this function exists in the code but is configured as false).

[0059] S4. Configuring Hot Updates and Code Recommendations For strategy 3 (OCR function), the system detected that this is a "feature flag". The system does not need to modify the code and directly sends the configuration update to some users' clients through the configuration center: enable_ocr = true.

[0060] For strategy 2 (front-end validation), the system generates a code Diff file and pushes it to the front-end manager.

[0061] S5. Effect Verification After the configuration was distributed, the system tracked the behavior of users who had enabled the OCR function in real time. The data changed from "confusion and pause" to "take a photo -> autofill -> confirm". The average completion time of this path was shortened from 3 minutes to 30 seconds, and the form submission success rate increased to 90%.

[0062] The system automatically generates a "User Experience Optimization Report," which details a comparison of user operation paths before and after optimization, a comparison of time consumption distribution histograms, and pushes this report to a project management tool (such as Jira), automatically closing the relevant "Poor User Experience" work orders.

[0063] Comparative analysis: Looking back at existing technologies, if the patented method is used, developers may generate comprehensive test cases after code changes to ensure the correctness of the "invoice verification interface" logic (i.e., input errors do indeed return a 4002 error). However, this existing technology can never discover user experience issues such as "users cannot understand the prompt text" or "users find manual input too tiring" through code testing.

[0064] This embodiment compensates for the lack of a code-side perspective by introducing user behavior data feedback, thus achieving a leap from "correct code logic" to "excellent user experience".

[0065] Example 3 This embodiment describes a cloud-native resource configuration automatic optimization scenario based on resource idle data, demonstrating the application of this method at the "software management" level.

[0066] S1. Resource and Behavior Relationship In a microservice architecture e-commerce system, the system detected that a Pod (container instance) of a certain "Promotion Service" maintained a configuration of 16GB of memory and 8 cores of CPU during non-major promotional periods.

[0067] Through user behavior analysis, the system found that in the past 30 days, the PV (page views) of the user entry point (coupon redemption page) corresponding to this service was extremely low, and the code path called was mainly concentrated in the read-only operation Query Coupon(), and never triggered the high-cost Calculate Discount() path.

[0068] S2. Waste Identification The system compared "extremely low user traffic" with "high-configuration container resources" and calculated that the resource utilization rate was only 2%.

[0069] Meanwhile, combined with static code analysis, the system confirmed that in the current code version, even the CalculateDiscount() logic only requires a peak memory consumption of 2GB.

[0070] S3. Configuration Optimization Closed Loop The system automatically generates Kubernetes HPA (Horizontal Autoscaling) configuration suggestions, or you can directly modify the Deployment's YAML file: Change requests.memory from 16Gi to 2Gi.

[0071] Adjust limits.cpu from 8 cores to 1 core.

[0072] Configure an automatic scaling-down strategy: When there is no user traffic between 2 AM and 6 AM, the number of replicas is reduced to 1.

[0073] S4. Safe Execution The system first applies the configuration in the pre-production environment and performs load testing by replaying real traffic from the past week. After confirming that there is no risk of Out of Memory (OOM), it is automatically applied to the production environment.

[0074] This process requires no manual intervention from developers and enables dynamic governance of the software runtime environment based on the user's actual workload.

[0075] In summary, this invention, through three-dimensional implementations (backend performance code optimization, frontend interaction logic optimization, and underlying resource configuration optimization), fully demonstrates how to leverage user behavior data feedback to drive comprehensive intelligent optimization of software development. This not only significantly improves the efficiency of software maintenance but also ensures that the direction of software evolution always aligns with user needs.

Claims

1. A software development intelligent optimization method based on user behavior data feedback, characterized in that, Includes the following steps: End-to-end behavioral data collection and preprocessing: Deploy non-intrusive tracking probes on the client and server sides to collect user operation behavior sequences, dwell time, interaction frequency, and corresponding server interface response data in real time; The collected data is cleaned, denoised, and session aggregated to construct a time-series graph of user behavior. Behavior-code mapping model construction: Obtain the source code of the software system, parse it to generate an abstract syntax tree and a static control flow graph; By combining runtime dynamic call chain tracing data, a multi-dimensional mapping relationship library is established between user interface elements, business operation events, and backend code classes, methods, and database query statements; Intelligent bottleneck mining and attribution analysis: Based on the aforementioned user behavior time series graph, graph neural networks are used to mine high-frequency and inefficient behavior patterns; By querying the multidimensional mapping relationship library, the inefficient behavior pattern can be traced back to at least one of the specific code snippets, configuration parameters, and database indexes, and a problem diagnosis report can be generated. Adaptive optimization strategy generation and closed-loop verification: Input the problem diagnosis report and associated code context into the pre-trained code optimization model to generate code refactoring suggestion patches and dynamic configuration adjustment instructions; In the sandbox environment, the generated patches and instructions are automatically deployed and tested. If the verification indicators improve, the optimization plan is merged into the main branch and selectively applied to the production environment according to the configuration.

2. The intelligent optimization method for software development based on user behavior data feedback according to claim 1, characterized in that, The specific process of establishing the multidimensional mapping relation library includes: By using bytecode enhancement technology, a tracking ID is injected at the entry and exit points of the server-side methods. This tracking ID is transparently associated with the session ID in the client request header. By analyzing call stack snapshots, the complete function call chain triggered by each type of user behavior and its resource consumption weight can be determined.

3. The intelligent optimization method for software development based on user behavior data feedback according to claim 1, characterized in that, The high-frequency, low-efficiency behavior patterns include repeated clicks, abnormal rollbacks, and long waiting times.

4. The intelligent optimization method for software development based on user behavior data feedback according to claim 1, characterized in that, The generated optimization strategies include: caching strategy injection for high-frequency repetitive calculation methods, index addition suggestions for slow query statements, resource degradation configuration for low-frequency functions, and simplified UI interaction code for redundant user operation paths.

5. The intelligent optimization method for software development based on user behavior data feedback according to claim 1, characterized in that, The client uses full-scale no-code tracking technology to automatically intercept click, swipe, input, and page jump events, and generates a unique element fingerprint through the DOM tree path.

6. The intelligent optimization method for software development based on user behavior data feedback according to claim 1, characterized in that, The server-side introduces a distributed tracing system based on the OpenTelemetry standard. When the client initiates an HTTP request, a globally unique TraceContext containing the session ID and transaction ID is injected into the request header.

7. The intelligent optimization method for software development based on user behavior data feedback according to claim 1, characterized in that, The data cleaning and aggregation process includes: the collected raw logs are transmitted to the real-time computing engine through a message queue; the preprocessing module uses a sliding window algorithm to align discrete end-side events with server-side tracking logs on the timeline using the session ID as the key. Filter out non-natural user behavior data generated by web crawlers and automated test scripts; The user behavior sequence is divided into several logically complete business operation flows.

8. The intelligent optimization method for software development based on user behavior data feedback according to claim 1, characterized in that, The process of constructing the static control flow graph includes: pulling source code from the code repository and using a code parsing tool to parse the source code to generate an abstract syntax tree; Based on the abstract syntax tree, all class definitions, method definitions, annotation information, and variable dependencies are extracted; Construct static control flow graphs and data flow graphs to clarify the call hierarchy between methods.

9. The intelligent optimization method for software development based on user behavior data feedback according to claim 1, characterized in that, The intelligent bottleneck mining and attribution analysis also includes: using sequence mining algorithms to identify negative patterns in user behavior data; Once a negative pattern is identified, the multidimensional mapping relationship library is queried to trace the corresponding backend call chain, locate the specific code and database query statement that caused the problem, and generate a diagnostic report that includes the problem phenomenon, root cause, and scope of impact.

10. The intelligent optimization method for software development based on user behavior data feedback according to claim 1, characterized in that, The closed-loop verification process includes: starting the CI / CD pipeline and deploying the generated patch to the canary environment; Import some real user traffic into this environment; Real-time monitoring of the behavioral data of this group of users; If the target response time decreases and no new error logs are generated, the optimization is considered successful. Once the optimization is successful, a merge request will be automatically submitted to the code repository, along with a performance comparison report.

Images