KR102613915B1 - Method, apparatus and program for automatically changing names of functions and parameters - Google Patents

Abstract

A method for automatically changing the names of functions and parameters according to various embodiments of the present invention is disclosed. The method includes: recognizing in real time a first source code including at least one undefined identifier input from a user terminal; Inputting the first source code into a function-name matching score calculation model and providing recommended parameter names and recommended variable names related to the at least one undefined identifier to the user terminal; Receive a first selection input for selecting one of the recommended parameter name and the recommended variable name from the user terminal, and generate a second source code in which the at least one identifier is defined based on the first selection input. steps; Inputting the second source code into the function-name matching score calculation model and providing a recommended function name related to the at least one identifier to the user terminal; and a third source that receives a second selection input for selecting one of the recommended function names from the user terminal, and defines the at least one identifier and a function name related to the at least one identifier based on the second selection input. Generating a code; and the function-name matching score calculation model may be retrained based on at least one of the first selection input and the second selection input.

Description

Method, device and program for automatically changing the names of functions and parameters {METHOD, APPARATUS AND PROGRAM FOR AUTOMATICALLY CHANGING NAMES OF FUNCTIONS AND PARAMETERS}

The present invention relates to a method, device, and program for automatically changing the names of functions and parameters, and more specifically, to a method, device, and program for automatically changing the names of functions and parameters included in source code.

Coding is essential to implement software used in various industries. This coding work is often performed collaboratively. Since coding work is done through collaboration, the names of functions, parameters, and various variables included in the source code can be important elements of smooth collaboration.

As the names of functions and parameters increase in importance, naming functions, parameters, and various variables is emerging as a pain point for workers.

This is because naming functions, parameters, and various variables is not simply about choosing the words the worker wants, but rather writing them intuitively and concisely so that other developers can easily understand them and for easy maintenance later.

For example, among coding tasks, the elements that require the most effort in naming include functions and parameters. There is no correct answer to the names (or definitions) of functions and parameters, and it requires a lot of time and effort to come up with names because it must depend on the operator's subjective opinion. In addition, in the general naming process, everything is done manually by the worker, so it depends on the individual worker's inclinations, and if the development period is not long enough, the name that was temporarily set may be used permanently as there is no opportunity to modify it.

For another example, after deciding on a name for the function to be implemented, the worker uses development documents or a series of processes to check whether the previously created name matches the conventions of the organization to which the developer belongs. The operator may implement the function right away without going through the confirmation process. In this case, if the function of the function is not clearly defined, the function may deviate from the function that was originally intended to be implemented, and at the same time, differences in the name and function of the function may occur. , If the function name is not changed to a name more suitable for the function after implementation is completed, mismatching between the name and function may occur.

The above-mentioned problems can cause maintenance difficulties and become obstacles to collaboration. In addition, due to the nature of the source code, there is no functional problem even if the variable name “A” is changed to “B”, but work efficiency may be reduced because a lot of time and effort is required to work on variable names.

Accordingly, there is a need in the art for a method to automatically change the names of functions and parameters. In this regard, Republic of Korea Patent Publication No. 10-2017-0042896 discloses a Java automatic identifier renaming technique.

The present invention was conceived in response to the above-described background technology and is intended to provide a method, device, and program for automatically changing the names of functions and parameters.

The technical problems of the present invention are not limited to the technical problems mentioned above, and other technical problems not mentioned will be clearly understood by those skilled in the art from the description below.

According to an embodiment of the present invention for solving the problems described above, a method for automatically changing the names of functions and parameters is disclosed. The method includes: recognizing in real time a first source code including at least one undefined identifier input from a user terminal; Inputting the first source code into a function-name matching score calculation model and providing recommended parameter names and recommended variable names related to the at least one undefined identifier to the user terminal; Receive a first selection input for selecting one of the recommended parameter name and the recommended variable name from the user terminal, and generate a second source code in which the at least one identifier is defined based on the first selection input. steps; Inputting the second source code into the function-name matching score calculation model and providing a recommended function name related to the at least one identifier to the user terminal; and a third source that receives a second selection input for selecting one of the recommended function names from the user terminal, and defines the at least one identifier and a function name related to the at least one identifier based on the second selection input. Generating a code; and the function-name matching score calculation model may be retrained based on at least one of the first selection input and the second selection input.

In an alternative embodiment, the function-name matching score calculation model is a context-based dynamic code analysis technique that analyzes the context and flow of the input code to understand the function of the input code. Based on this, it can be learned using learning data labeled with an identifier containing the function of the code and the meaning corresponding to the function.

In an alternative embodiment, the function-name match score calculation model outputs a function-name match score, and the function-name match score is calculated by excluding the identifier from the input code. As the code is converted and analyzed into a code in which only the function exists, it may be a numeric value calculated along with an identifier containing the function and the meaning corresponding to the function.

In an alternative embodiment, inputting the first source code into the function-name matching score calculation model to provide a recommended parameter name and a recommended variable name related to the at least one undefined identifier to the user terminal. providing the function-name matching score corresponding to each of the recommended parameter name and the recommended variable name; and providing a number of selections for each of the recommended parameter names and the recommended variable names selected to date for each of the at least one undefined identifier, wherein, based on the first selection input, the number of selections. can be updated.

In an alternative embodiment, the method includes recognizing whether a variable or parameter that must exist in a specific function included in the first source code does not exist based on the function-name matching score calculation model; and when it is recognized that the variable or parameter that must exist in the specific function does not exist, recommending an identifier corresponding to the missing variable or missing parameter.

In an alternative embodiment, the method may include, when the first selection input for selecting one of the recommended parameter name and the recommended variable name is not received and a manually entered identifier is received, the manually entered identifier is evaluating step; It may further include retraining the function-name matching score calculation model by labeling the manually input identifier and a function of a code corresponding to the manually input identifier.

According to one embodiment of the present invention for solving the above-described problems, a device is disclosed. The device includes: a memory storing one or more instructions; and a processor executing the one or more instructions stored in the memory, and the processor may perform the above-described methods by executing the one or more instructions.

According to an embodiment of the present invention for solving the above-described problem, a computer program is disclosed that is combined with a computer as hardware and stored in a computer-readable recording medium to perform the above-described methods.

Other specific details of the invention are included in the detailed description and drawings.

The present invention can increase work efficiency by automatically processing naming tasks for functions and parameters that require high difficulty during coding work.

The effects of the present invention are not limited to the effects mentioned above, and other effects not mentioned will be clearly understood by those skilled in the art from the description below.

1 is a diagram illustrating a system according to an embodiment of the present invention.
Figure 2 is a hardware configuration diagram of a server according to an embodiment of the present invention.
Figure 3 is a schematic diagram illustrating a method for automatically changing the names of functions and parameters according to an embodiment of the present invention.
Figure 4 is a flowchart illustrating an example of a method for automatically changing the names of functions and parameters according to an embodiment of the present invention.
5, 6, and 7 are flowcharts illustrating an example of a method for automatically changing the names of functions and parameters according to various embodiments of the present invention.
Figure 8 is a flowchart illustrating an example of a method for learning a neural network model according to an embodiment of the present invention.
Figure 9 is a schematic diagram showing one or more activation functions related to one embodiment of the present invention.

Various embodiments are now described with reference to the drawings. In this specification, various descriptions are presented to provide an understanding of the invention. However, it is clear that these embodiments may be practiced without these specific descriptions.

As used herein, the terms “component,” “module,” “system,” and the like refer to a computer-related entity, hardware, firmware, software, a combination of software and hardware, or an implementation of software. For example, a component may be, but is not limited to, a process running on a processor, a processor, an object, a thread of execution, a program, and/or a computer. For example, both an application running on a computing device and the computing device can be a component. One or more components may reside within a processor and/or thread of execution. A component may be localized within one computer. A component may be distributed between two or more computers. Additionally, these components can execute from various computer-readable media having various data structures stored thereon. Components can transmit signals, for example, with one or more data packets (e.g., data and/or signals from one component interacting with other components in a local system, a distributed system, to other systems and over a network such as the Internet). Depending on the data being transmitted, they may communicate through local and/or remote processes.

Additionally, the term “or” is intended to mean an inclusive “or” and not an exclusive “or.” That is, unless otherwise specified or clear from context, “X utilizes A or B” is intended to mean one of the natural implicit substitutions. That is, either X uses A; X uses B; Or, if X uses both A and B, “X uses A or B” can apply to either of these cases. Additionally, the term “and/or” as used herein should be understood to refer to and include all possible combinations of one or more of the related listed items.

Additionally, the terms “comprise” and/or “comprising” should be understood to mean that the corresponding feature and/or element is present. However, the terms “comprise” and/or “comprising” should be understood as not excluding the presence or addition of one or more other features, elements and/or groups thereof. Additionally, unless otherwise specified or the context is clear to indicate a singular form, the singular terms herein and in the claims should generally be construed to mean “one or more.”

Those skilled in the art will additionally recognize that the various illustrative logical blocks, components, modules, circuits, means, logic, and algorithm steps described in connection with the embodiments disclosed herein may be implemented using electronic hardware, computer software, or a combination of both. It must be recognized that it can be implemented with To clearly illustrate the interchangeability of hardware and software, various illustrative components, blocks, configurations, means, logics, modules, circuits, and steps have been described above generally in terms of their functionality. Whether such functionality is implemented in hardware or software will depend on the specific application and design constraints imposed on the overall system. A skilled technician can implement the described functionality in a variety of ways for each specific application. However, such implementation decisions should not be construed as departing from the scope of the present invention.

The description of the presented embodiments is provided to enable anyone skilled in the art to use or practice the present invention. Various modifications to these embodiments will be apparent to those skilled in the art. The general principles defined herein may be applied to other embodiments without departing from the scope of the invention. Therefore, the present invention is not limited to the embodiments presented herein. The present invention is to be interpreted in the broadest scope consistent with the principles and novel features presented herein.

In this specification, a computer refers to all types of hardware devices including at least one processor, and depending on the embodiment, it may be understood as encompassing software configurations that operate on the hardware device. For example, a computer can be understood to include, but is not limited to, a smartphone, tablet PC, desktop, laptop, and user clients and applications running on each device.

Hereinafter, embodiments of the present invention will be described in detail with reference to the attached drawings.

Each step described in this specification is described as being performed by a computer, but the subject of each step is not limited thereto, and depending on the embodiment, at least part of each step may be performed in a different device.

1 is a diagram illustrating a system according to an embodiment of the present invention.

Referring to FIG. 1, a system according to an embodiment of the present invention may include a server 100, a terminal 200, and an external server 300. The system shown in FIG. 1 is according to one embodiment, and its components are not limited to the embodiment shown in FIG. 1, and may be added, changed, or deleted as necessary.

In one embodiment, the server 100 may perform a method of automatically changing the names of functions and parameters. Additionally, the server 100 may provide a service for automatically changing the names of functions and parameters to the user terminal 200.

For example, when the server 100 receives source code whose function and parameter names have not been changed from the user terminal 200, the server 100 may transmit the source code with the function name and parameter names changed to the user terminal 200. You can.

For example, the worker performing the coding task consists of arbitrary function name identifiers such as “method_1, method_2” and arbitrary parameter name identifiers such as “param_1, param_2” on the Integrated Development Environment (IDE). You can write source code and implement the function of the function. The operator selects (e.g., selects by dragging) the function for which implementation has been completed and enters the names of the “functions and parameters” of the present invention installed as an extension program (e.g., extension) on the integrated development environment. You can run a “service that changes automatically.” At this time, the server 100 of the present invention may suggest a parameter name to the operator. In this case, the operator can select a suggested parameter name or enter it directly if no name is deemed suitable. Additionally, after the modification of the parameter name is completed, the server 100 may suggest a function name to the worker based on the modified code. In this case, the operator can select the suggested function name or enter it directly if no name is deemed suitable. Additionally, the operator can obtain source code with both function names and parameter names modified. Meanwhile, the modified code can be stored in the server 100 for later re-learning.

In one embodiment, the server 100 may recognize the first source code including at least one undefined identifier input from the user terminal 200 in real time.

When the server 100 recognizes the first source code in real time, the server 100 uses a function-name match score calculation model that receives the first source code to select a recommended parameter name and a recommended variable related to at least one undefined identifier. The name can be decided. Additionally, the server 100 may provide recommended parameter names and recommended variable names to the user terminal 200.

The server 100 may receive a first selection input for selecting one of the recommended parameter name and the recommended variable name from the user terminal 200. In this case, the server 100 may generate a second source code in which at least one identifier is defined based on the first selection input. Additionally, the server 100 may retrain the function-name matching score calculation model based on the first selection input.

When the server 100 generates the second source code, the server 100 may determine a recommended function name related to at least one identifier using a function-name matching score calculation model that receives the second source code. Additionally, the server 100 may provide the recommended function name to the user terminal 200.

The server 100 may receive a second selection input for selecting one of the recommended function names from the user terminal 200. In this case, the server 100 may generate a third source code in which at least one identifier and a function name related to the at least one identifier are defined based on the second selection input. Additionally, the server 100 may retrain the function-name matching score calculation model based on the second selection input.

That is, the server 100 may define an identifier in source code including at least one undefined identifier input from the user terminal 200, and generate source code in which a function name related to the defined identifier is defined. Accordingly, the server 100 can increase the efficiency of coding work by providing assistance with naming tasks for functions and parameters.

In various embodiments, the server 100 may receive source code from the user terminal 200 in which the names of functions and parameters are not changed. In this case, the server 100 inputs the source code into the pre-trained neural network model, determines the parameter name of each at least one parameter included in the source code, and determines the parameter name of each at least one function included in the source code. The function name can be determined. Here, the neural network model may be a function-name matching score calculation model.

Specifically, the server 100 may obtain candidate names for each of at least one parameter and at least one function from a pre-trained neural network that receives source code, and transmit them to the user terminal 200. In this case, the user terminal 200 may transmit selection information for selecting one of the candidate names or directly input information to the server 100. Meanwhile, the server 100 may determine the name of each of at least one parameter and at least one function included in the source code based on selection information or user input information directly entered by the user.

Additionally, the server 100 may change each of at least one parameter included in the source code to a parameter name determined by the method described above, and change each of at least one function to a function name determined by the method described above. Additionally, the server 100 may provide source code with changed parameter names and function names to the user terminal 200.

Therefore, the server 100 of the present invention can increase the efficiency of coding work by providing assistance with naming tasks for functions and parameters.

Hereinafter, an example of a method by which the server 100 automatically changes the names of functions and parameters will be described with reference to FIGS. 3 to 8.

In various embodiments, the server 100 may provide web- or application-based services. However, it is not limited to this.

Server 100 may include any type of computer system or computer device, such as, for example, microprocessors, mainframe computers, digital processors, portable devices, and device controllers. However, it is not limited to this.

Hereinafter, the hardware configuration of the server 100 will be described with reference to FIG. 2.

Meanwhile, the user terminal 200 may be connected to the server 100 through the network 400, and may be a user terminal using a service that automatically changes the names of functions and parameters provided by the server 100. there is. For example, the user terminal 200 may be a terminal of a worker or developer performing coding work.

Here, the user terminal 200 may include, for example, various types of computer devices. For example, the user terminal 200 may refer to various terminal devices such as a smartphone, tablet PC, desktop, or laptop.

The user terminal 200 includes a display in at least a portion of the terminal, and may include an operating system for running an application or extension program-based service provided from the server 100. For example, the user terminal 200 may be a smart phone, but is not limited to this. The user terminal 200 is a wireless communication device that guarantees portability and mobility, and may be used for navigation, personal communication (PCS), etc. System), GSM (Global System for Mobile communications), PDC (Personal Digital Cellular), PHS (Personal Handyphone System), PDA (Personal Digital Assistant), IMT (International Mobile Telecommunication)-2000, CDMA (Code Division Multiple Access)- 2000, all types of handheld-based wireless communication devices such as W-CDMA (W-Code Division Multiple Access), Wibro (Wireless Broadband Internet) terminals, smartpads, tablet PCs, etc. It can be included.

The external server 300 can be connected to the server 100 through the network 400, and the server 100 can transmit and receive various information/data necessary to provide a service that automatically changes the names of functions and parameters. It is possible to store and manage various information/data generated as the server 100 provides a service that automatically changes the names of functions and parameters.

For example, the external server 300 may be a database server that stores information used in a service that automatically changes the names of functions and parameters. For another example, the external server 300 may be a server that provides information used in a service that automatically changes the names of functions and parameters.

The network 400 may refer to a connection structure that allows information exchange between nodes such as a computing device, a plurality of terminals, and servers. For example, the network 400 includes a local area network (LAN), a wide area network (WAN), the World Wide Web (WWW), a wired and wireless data communication network, a telephone network, and a wired and wireless television communication network. do.

Wireless data communication networks include 3G, 4G, 5G, 3GPP (3rd Generation Partnership Project), 5GPP (5th Generation Partnership Project), LTE (Long Term Evolution), WIMAX (World Interoperability for Microwave Access), Wi-Fi, and Internet. (Internet), LAN (Local Area Network), Wireless LAN (Wireless Local Area Network), WAN (Wide Area Network), PAN (Personal Area Network), RF (Radio Frequency), Bluetooth (Bluetooth) network, NFC (Near- Field Communication) network, satellite broadcasting network, analog broadcasting network, DMB (Digital Multimedia Broadcasting) network, etc., but is not limited thereto.

Figure 2 is a hardware configuration diagram of a server according to an embodiment of the present invention.

Referring to FIG. 2, the server 100 according to an embodiment of the present invention includes one or more processors 110, a memory 120 that loads a computer program 151 executed by the processor 110, It may include a bus 130, a communication interface 140, and a storage 150 that stores a computer program 151. Here, only components related to the embodiment of the present invention are shown in Figure 2. Accordingly, anyone skilled in the art to which the present invention pertains will know that other general-purpose components may be included in addition to the components shown in FIG. 2.

The processor 110 controls the overall operation of each component of the server 100. The processor 110 may be composed of one or more cores, and may include a central processing unit (CPU), a general purpose graphics processing unit (GPGPU), and a tensor processing unit (TPU) of the computing device. unit) may include a processor for data analysis and deep learning. Alternatively, it may be configured to include any type of processor well known in the art of the present invention.

Additionally, the processor 110 may perform operations on at least one application or program for executing methods according to embodiments of the present invention, and the server 100 may include one or more processors.

In various embodiments, the processor 110 includes random access memory (RAM) (not shown) and read memory (ROM) that temporarily and/or permanently store signals (or data) processed within the processor 110. -Only Memory, not shown) may be further included. Additionally, the processor 110 may be implemented in the form of a system on chip (SoC) that includes at least one of a graphics processing unit, RAM, and ROM.

Memory 120 stores various data, commands and/or information. Memory 120 may load a computer program 151 from storage 150 to execute methods/operations according to various embodiments of the present invention. When the computer program 151 is loaded into the memory 120, the processor 110 can perform the method/operation by executing one or more instructions constituting the computer program 151. The memory 120 may be implemented as a volatile memory such as RAM, but the technical scope of the present invention is not limited thereto.

The bus 130 provides communication functions between components of the server 100. The bus 130 may be implemented as various types of buses, such as an address bus, a data bus, and a control bus.

The communication interface 140 supports wired and wireless Internet communication of the server 100. Additionally, the communication interface 140 may support various communication methods other than Internet communication. To this end, the communication interface 140 may be configured to include a communication module well known in the technical field of the present invention. In some embodiments, communication interface 140 may be omitted.

Storage 150 may store the computer program 151 non-temporarily. When performing a process according to an embodiment of the present invention through the server 100, the storage 150 may store various information necessary to perform analysis according to the disclosed embodiment.

The storage 150 is a non-volatile memory such as Read Only Memory (ROM), Erasable Programmable ROM (EPROM), Electrically Erasable Programmable ROM (EEPROM), flash memory, a hard disk, a removable disk, or a device well known in the technical field to which the present invention pertains. It may be configured to include any known type of computer-readable recording medium.

The computer program 151, when loaded into the memory 120, may include one or more instructions that cause the processor 110 to perform methods/operations according to various embodiments of the present invention. That is, the processor 110 can perform the method/operation according to various embodiments of the present invention by executing the one or more instructions.

In one embodiment, computer program 151 may include one or more instructions to perform various methods related to various tasks related to training a neural network model.

The steps of the method or algorithm described in connection with embodiments of the present invention may be implemented directly in hardware, implemented as a software module executed by hardware, or a combination thereof. The software module may be RAM (Random Access Memory), ROM (Read Only Memory), EPROM (Erasable Programmable ROM), EEPROM (Electrically Erasable Programmable ROM), Flash Memory, hard disk, removable disk, CD-ROM, or It may reside on any type of computer-readable recording medium well known in the art to which the present invention pertains.

The components of the present invention may be implemented as a program (or application) and stored in a medium in order to be executed in conjunction with a hardware computer. Components of the invention may be implemented as software programming or software elements, and similarly, embodiments may include various algorithms implemented as combinations of data structures, processes, routines or other programming constructs, such as C, C++, , may be implemented in a programming or scripting language such as Java, assembler, etc. Functional aspects may be implemented as algorithms running on one or more processors.

Figure 3 is a schematic diagram illustrating a method for automatically changing the names of functions and parameters according to an embodiment of the present invention.

According to one embodiment of the present invention, the server 100 may provide a service that supports the user's coding work. Specifically, the server 100 may provide a service that supports naming functions and parameters that coders find difficult.

Referring to FIG. 3, the user terminal 200 may transmit the first source code to the server 100. Here, the first source code may be source code in which the names of functions and parameters are not changed.

The server 100 may obtain a candidate name for each of at least one parameter included in the first source code through the learned neural network model. In addition, the server 100 provides a selection interface to the user terminal 200 to obtain selection information for selecting a parameter name from among candidate names or user input information directly input by the user, and selects each of at least one parameter. The parameter name can be determined. In this case, the server 100 may generate the second source code by changing the name of each of at least one parameter included in the first source code to the determined parameter name. Here, the second source code may be a source code in which the name of the function is not changed and only the name of the parameter is changed.

After generating the second source code, the server 100 may obtain a candidate name for each of at least one function included in the second source code through a learned neural network model. Then, the server 100 provides a selection interface to the user terminal 200, obtains selection information for selecting a function name among candidate names or user input information directly entered by the user, and determines the function name of each at least one function. You can. In this case, the server 100 may generate the third source code by changing the name of each of at least one function included in the second source code to the determined function name. And, the server 100 may transmit the third source code to the user terminal 200.

Therefore, the server 100 of the present invention provides an immediate correction function for the names of functions and parameters included in the source code, and can cause the names of functions and parameters to be consistent. Additionally, the server 100 can increase work efficiency by lowering the difficulty of naming for workers.

Meanwhile, each of the second and third source codes modified based on selection information or user input information received through the selection interface can be used to retrain the neural network model. In other words, the neural network model of the present invention is updated as the user uses it, and can provide the user with candidate names that become progressively more accurate.

Hereinafter, a specific embodiment of a method for automatically changing the names of the above-described functions and parameters will be described with reference to FIGS. 4 to 7.

Figure 4 is a flowchart illustrating an example of a method for automatically changing the names of functions and parameters according to an embodiment of the present invention.

According to one embodiment of the present invention, the server 100 can recognize in real time that a user writes source code using a meaningless identifier (i.e., an undefined identifier) in the user terminal 200. Additionally, the server 100 can complete the source code by providing recommended parameter names, recommended variable names, and recommended function names for meaningless identifiers included in the source code.

Specifically, referring to FIG. 4, the server 100 may recognize in real time the first source code including at least one undefined identifier input from the user terminal 200 (S1). Then, the server 100 may input the first source code into the function-name matching score calculation model and provide recommended parameter names and recommended variable names related to at least one undefined identifier to the user terminal (S2 ).

The function-name matching score calculation model of the present invention can be retrained based on a first selection input that selects one of the recommended parameter name and the recommended variable name. Additionally, the function-name matching score calculation model may be retrained based on a second selection input that selects one of the recommended function names.

Accordingly, the more the function-name matching score calculation model of the present invention is used, the more it can be updated to output a result that is closer to the user's selection (i.e., has a higher probability of the user's selection).

In addition, the function-name matching score calculation model can be learned based on the context-based Dynamic Code Analysis technique, which analyzes the context and flow of the input code to understand the function of the input code. there is. Specifically, the function-name matching score calculation model can be learned using training data labeled with the function of the code and an identifier containing the meaning corresponding to the function.

Additionally, the function-name matching score calculation model can output the function-name matching score. Here, the function-name match score is calculated along with the function and identifier containing the meaning corresponding to the function as the function-name match score calculation model analyzes the input code by converting it into a code that contains only the function, excluding the identifier. It can be a numeric value.

For example, when the function-name match score calculation model recognizes the first function, the first score corresponding to the first identifier corresponding to the first function, the second score corresponding to the second identifier corresponding to the first function A score and a third score corresponding to a third identifier corresponding to the first function may be output. In this case, the server 100 may recommend the first identifier, second identifier, and third identifier for the first function to the user as recommended parameter names or recommended variable names.

When the server 100 provides a recommended parameter name and a recommended variable name to the user terminal, it can provide a function-name matching score corresponding to each of the recommended parameter name and recommended variable name. Additionally, the server 100 may provide the number of times each of the recommended parameter names and recommended variable names selected to date has been selected for each of at least one undefined identifier. Additionally, the server 100 may update the number of selections based on the first selection input received from the user terminal 200.

After providing the recommended parameter name and the recommended variable name to the user terminal 200, the server 100 receives a first selection input for selecting one of the recommended parameter name and the recommended variable name from the user terminal 200. can do. In this case, the server 100 may generate a second source code in which at least one identifier is defined based on the first selection input (S3). Then, the server 100 may input the second source code into the function-name matching score calculation model and provide a recommended function name related to at least one identifier to the user terminal (S4).

After providing the recommended function name to the user terminal 200, the server 100 receives a second selection input for selecting one of the recommended function names from the user terminal 200, and receives at least one selection input based on the second selection input. A third source code in which an identifier and at least one function name related to the identifier are defined can be generated (S5).

In various embodiments, the server 100 may recognize in real time that a user writes source code on the user terminal 200. In this case, the server 100 can recognize whether a missing variable or missing parameter exists in the source code. Additionally, if a missing variable or missing parameter exists, the server 100 may recommend an identifier for the variable or parameter.

Specifically, the server 100 may recognize whether a variable or parameter that must exist in a specific function included in the first source code does not exist based on the function-name matching score calculation model. Additionally, when the server 100 recognizes that a variable or parameter that must be present in a specific function does not exist, the server 100 may recommend an identifier corresponding to the missing variable or missing parameter.

Therefore, the server 100 of the present invention can improve the completeness of the source code and increase the productivity of coding work by preventing errors that occur due to omission of variables or parameters.

According to various embodiments, in step S3, if the first selection input for selecting one of the recommended parameter name and the recommended variable name is not received and a manually entered identifier is received, the server 100 The entered identifier can be evaluated.

For example, the server 100 may evaluate the manually entered identifier based on whether the meaning is appropriate, the length is appropriate, or whether a typo exists. For example, the server 100 calculates a score for each of the above-mentioned evaluation items, and if the sum of each score is greater than or equal to a preset value, the server 100 may evaluate the manually entered identifier as a normal identifier.

When the server 100 completes the evaluation, it can retrain the function-name matching score calculation model by labeling the manually entered identifier and the function of the code corresponding to the manually entered identifier.

Accordingly, the server 100 of the present invention can have scalability for the name of the identifier by evaluating the identifier manually entered by the user and retraining the model.

5, 6, and 7 are flowcharts illustrating an example of a method for automatically changing the names of functions and parameters according to various embodiments of the present invention.

According to one embodiment of the present invention, the server 100 may receive the first source code from the user terminal 200 in which the names of functions and parameters are not changed. Additionally, the server 100 may determine the parameter name of each of at least one parameter included in the first source code by inputting the first source code into the first neural network model for determining the parameter name. Additionally, the server 100 may generate a second source code by modifying the first source code based on the parameter name. Additionally, the server 100 may determine the function name of each of at least one function included in the second source code by inputting the second source code into the second neural network model for determining the function name. Additionally, the server 100 may generate a third source code by further modifying the second source code based on the function name.

The first neural network model and the second neural network model of the present invention may be a function-name matching score calculation model.

In various embodiments, the server 100 determines the parameter name of each of at least one parameter included in the first source code by inputting the first source code into a first neural network model for determining the parameter name. , the first source code can be input into the first neural network model to obtain a first candidate name corresponding to each of at least one parameter. Additionally, the server 100 may provide the first candidate name to the user terminal 200 and receive a selection input or user input for selecting one of the first candidate names from the user terminal 200. Additionally, the server 100 may determine a parameter name for each of at least one parameter based on a selection input or user input.

In various embodiments, when the server 100 inputs the first source code into the first neural network model and obtains a first candidate name corresponding to each of at least one parameter, the server 100 adds a specific parameter to the first neural network model. By inputting the parameter name output from the first neural network model, the score for each class can be recognized. Additionally, the server 100 may determine at least one name whose score is greater than or equal to a preset value as the first candidate name corresponding to a specific parameter.

In various embodiments, the first source code may be a source code in which an identifier for identifying a different parameter is inserted in place of each of at least one parameter. On the other hand, when the server 100 generates the second source code by modifying the first source code based on the parameter name, when the parameter name corresponding to the specific parameter is determined, the specific parameter included in the first source code You can search for the identifier of a variable. Additionally, the server 100 may generate a second source code by changing the identifier of a specific parameter to a parameter name corresponding to the specific parameter. Here, the first neural network model may be retrained based on the second source code.

In various embodiments, when the server 100 determines the function name of each of at least one function included in the second source code by inputting the second source code into the second neural network model for determining the function name, the second source code By inputting into the second neural network model, a second candidate name corresponding to each of at least one function can be obtained. Additionally, the server 100 may provide the second candidate name to the user terminal 200 and receive a selection input or user input for selecting one of the second candidate names from the user terminal 200. Additionally, the server 100 may determine the function name of each at least one function based on a selection input or user input.

In various embodiments, the server 100 inputs the second source code into the second neural network model, and when obtaining a second candidate name corresponding to each of at least one function, inputs a specific function into the second neural network model. , the score for each function name class output by the second neural network model can be recognized. Additionally, the server 100 may determine at least one name whose score is greater than or equal to a preset value as a second candidate name corresponding to a specific function.

In various embodiments, the source code may be source code in which an identifier for identifying a different function is inserted in place of each of at least one function. Meanwhile, when the server 100 generates a third source code by additionally modifying the second source code based on the function name, when the function name corresponding to the specific function is determined, the identifier of the specific function included in the second source code You can explore. Additionally, the server 100 may generate a third source code by changing the identifier of a specific function to a function name corresponding to the specific function. Here, the third source code is transmitted to the user terminal 200, and the second neural network model can be retrained based on the third source code.

In various embodiments, the server 100 may acquire a plurality of completed source codes based on a specific code convention for learning a neural network model. Additionally, the server 100 can recognize functions in each of a plurality of source codes and recognize parameters constituting the functions. Additionally, the server 100 can recognize the structure of the function and the name of the function, and train the second neural network model using learning data that labels the structure of the function with the name of the function. In addition, the server 100 recognizes the positions and names of the parameters constituting the function, and creates a first neural network model using learning data that labels the names of the parameters in the positions of the parameters constituting the function. It can be learned.

Referring to FIG. 5, the server 100 may receive the first source code in which the names of functions and parameters are not changed from the user terminal 200 (S110).

The first source code of the present invention may include at least one parameter and at least one function. Additionally, the first source code may be a source code in which identifiers (eg, param_1, param_2) for identifying different parameters are inserted into each position of at least one parameter. Additionally, the first source code may be a source code in which an identifier (for example, method_1, method_2) for identifying a different function is inserted in place of each of at least one function.

The server 100 may determine the parameter name of each of at least one parameter included in the first source code by inputting the first source code into the first neural network model for determining the parameter name (S120).

Specifically, referring to FIG. 6, the server 100 may input the first source code into the first neural network model to obtain a first candidate name corresponding to each of at least one parameter (S121).

More specifically, the server 100 may input a specific parameter into the first neural network model and recognize the score for each parameter name class output from the first neural network model.

For example, the server 100 may input the location of a specific parameter included in the source code into the first neural network model. Here, the location of a specific parameter may be the location of a parameter located within a specific function. In this case, the first neural network model may output a score for each parameter name class based on the location of a specific parameter.

For example, when the first neural network model receives the position of a specific parameter included in the source code, it can calculate and output a score for each of a plurality of classes divided by the name of the parameter. Here, the total score for each of the plurality of classes may be 1. For example, if there are five parameter names A, B, C, D, and E, the first neural network model can calculate a score for each of the five classes.

The first neural network model of the present invention may be a multi-classification model, and the number of classes of the first neural network model may correspond to the number of parameter name types recognized in a plurality of completed source codes, but is not limited thereto.

Hereinafter, a description of how the server 100 pre-trains the first neural network model will be described later with reference to FIG. 8.

Meanwhile, when the server 100 recognizes the score for each parameter name class, it may determine at least one name whose score for each parameter name class is more than a preset value as the first candidate name corresponding to the specific parameter.

For example, the score of parameter name A is recognized as 0.3, the score of parameter name B is 0.1, the score of parameter name C is 0.2, the score of parameter name D is 0.3, and the score of parameter name E is recognized as 0.1. In this case, the server 100 may determine parameter names A, C, and D with a preset score value of 0.2 or more as the first candidate names.

When the server 100 obtains the first candidate name, the server 100 may provide the first candidate name to the user terminal 200. Additionally, the server 100 may receive a selection input or user input for selecting one of the first candidate names from the user terminal 200 (S122). Additionally, the server 100 may determine the parameter name of each at least one parameter based on the selection input or user input (S123).

Specifically, the server 100 may provide a list for selecting one of the first candidate names to the user terminal 200 through a user interface related to a service that automatically changes the names of functions and parameters. Additionally, the server 100 may provide an input window where input is possible when there is no appropriate name among the first candidate names. Additionally, the server 100 may determine the parameter name of each of at least one parameter by obtaining information selected or input through the user interface.

Referring again to FIG. 5, when the server 100 determines the parameter name of each of at least one parameter included in the first source code, the server 100 modifies the first source code based on the parameter name to produce the second source code. can be created (S130).

Specifically, when the parameter name corresponding to a specific parameter is determined, the server 100 may search for the identifier of the specific parameter included in the first source code. Additionally, the server 100 may generate a second source code by changing the identifier of a specific parameter to a parameter name corresponding to the specific parameter. Here, the second source code can be used to retrain the first neural network model.

When the server 100 generates the second source code, the server 100 may determine the function name of each of at least one function included in the second source code by inputting the second source code into the second neural network model for determining the function name ( S140).

Specifically, referring to FIG. 7, the server 100 may input a second source code into a second neural network model to obtain a second candidate name corresponding to each of at least one function (S141).

More specifically, the server 100 may input a specific function into the second neural network model and recognize the score for each function name class output by the second neural network model. Additionally, the server 100 may determine at least one name whose score is greater than or equal to a preset value as a second candidate name corresponding to a specific function.

For example, the server 100 may input the structure of a specific function included in the source code into the second neural network model. Here, the structure of the specific function may be a structure determined based on the number of parameters included in the specific function or the types of parameters constituting the specific function. In this case, the second neural network model can output a score for each function name class based on the structure of a specific function.

The second neural network model of the present invention may be a multi-classification model, and the number of classes of the second neural network model may correspond to the number of function name types recognized in a plurality of completed source codes, but is not limited thereto.

Hereinafter, the method by which the server 100 determines the second candidate name using the second neural network model may be the same as the method described with reference to step S121 of FIG. 6, and overlapping descriptions will be omitted. A description of how the server 100 trains the second neural network model in advance will be described later with reference to FIG. 8.

Meanwhile, when the server 100 obtains the second candidate name, it provides the second candidate name to the user terminal 200 and provides a selection input for selecting one of the second candidate names from the user terminal 200. Alternatively, user input may be received (S142). Then, the server 100 may determine the function name of each at least one function based on the selection input or user input (S143).

Specifically, the server 100 may provide a list for selecting one of the second candidate names to the user terminal 200 through a user interface related to a service that automatically changes the names of functions and parameters. Additionally, the server 100 may provide an input window where input is possible when there is no appropriate name among the second candidate names. Additionally, the server 100 may determine the parameter name of each of at least one parameter by obtaining information selected or input through the user interface.

Referring again to FIG. 5, when the server 100 determines the function name of each of at least one function included in the second source code, the server 100 generates the third source code by further modifying the second source code based on the function name. (S150).

Specifically, when the function name corresponding to a specific function is determined, the server 100 may search for the identifier of the specific function included in the second source code. Additionally, the server 100 may generate a third source code by changing the identifier of a specific function to a function name corresponding to the specific function. Here, the third source code can be used to retrain the second neural network model.

Meanwhile, the third source code generated by the server 100 may be transmitted to the user terminal 200 that provided the first source code.

Accordingly, the server 100 of the present invention can increase work efficiency by automatically processing naming tasks for functions and parameters that require high difficulty during coding work.

In an additional embodiment, the server 100 may integrate source code worked by each of a plurality of workers for one project and change function names and parameter names included in the source code to suit specific coding style conventions.

Specifically, the server 100 may receive a first work from a first worker terminal that is a worker of a specific project, and may receive a second work from a second worker terminal that is a worker of the specific project. Here, each of the first work and the second work may mean source code.

When receiving the first work and the second work, the server 100 recognizes at least one parameter included in the first work and recognizes at least one parameter included in the second work. You can. Additionally, the server 100 may compare parameters included in each of the first work and the second work to recognize parameters that do not overlap with each other.

The server 100 may input information related to non-overlapping parameter names into a first neural network model for determining parameter names, and recognize scores for each parameter name class output by the first neural network model. Here, the information related to non-overlapping parameter names may be part of the source code including non-overlapping parameter names, but is not limited to this, and includes various input data for outputting candidate names related to the parameter names. can do.

Additionally, the server 100 may determine the parameter name with the highest class score for each non-overlapping parameter name as the temporary parameter name. When the server 100 determines a temporary parameter name, the server 100 may change non-overlapping parameter names included in each of the first work and the second work to the temporary parameter name.

The server 100 may change non-overlapping parameter names included in each of the first work and the second work to temporary parameter names, and then recognize again whether non-overlapping parameter names exist. there is. The server 100 may determine overlapping temporary parameter names as parameter names for each of the first work and the second work.

Meanwhile, when the server 100 recognizes that non-overlapping parameter names exist after changing the term parameter name, it sends the first worker terminal, the second worker terminal, and a plurality of other worker terminals related to the specific project respectively. User input can be requested to determine non-overlapping parameter names. And, when the server 100 receives a plurality of user inputs from each of the first worker terminal, the second worker terminal, and a plurality of other worker terminals related to a specific project, the number of duplicates is calculated based on the plurality of user inputs. The most common names can be determined as parameter names that do not overlap each other.

Additionally, when receiving the first work and the second work, the server 100 recognizes at least one function included in the first work and recognizes at least one function included in the second work. You can. Additionally, the server 100 may compare functions included in each of the first work and the second work to recognize function names that do not overlap with each other.

The server 100 may input information related to non-overlapping function names into the second neural network model for determining the function name, and recognize the score for each function name class output by the second neural network model. Here, the information related to the non-overlapping function names may be a part of the source code including the non-overlapping function names, but is not limited thereto and may include various input data for outputting candidate names related to the function names.

Additionally, the server 100 may determine the function name with the highest class score for each non-overlapping function name as the temporary function name. When the server 100 determines a temporary function name, the server 100 may change non-overlapping function names included in each of the first work and the second work to the temporary function name.

The server 100 may change non-overlapping function names included in each of the first work and the second work to temporary function names, and then recognize again whether non-overlapping function names exist. Here, the server 100 may determine the overlapping temporary function names as the function names of each of the first work and the second work.

On the other hand, when the server 100 recognizes that there is a function name that does not overlap each other after changing the term function name, the first worker terminal, the second worker terminal, and the other plurality of worker terminals related to the specific project do not overlap each other. User input can be requested to determine the name of the function name. And, when the server 100 receives a plurality of user inputs from each of the first worker terminal, the second worker terminal, and a plurality of other worker terminals related to a specific project, the number of duplicates is calculated based on the plurality of user inputs. The most common names can be determined as non-overlapping function names.

The server 100 may transmit a work in which the function name and parameter name have been changed to suit a specific coding style protocol to each of the first worker terminal and the second worker terminal.

Accordingly, the server 100 of the present invention can prevent difficulties in maintenance that may occur due to the name of a function or parameter temporarily determined by the operator being fixed.

Figure 8 is a flowchart illustrating an example of a method for learning a neural network model according to an embodiment of the present invention.

According to an embodiment of the present invention, the server 100 may train a first neural network model for determining parameter names and a second neural network model for determining function names.

Referring to FIG. 8, the server 100 may obtain a plurality of completed source codes based on a specific code convention for learning a neural network model (S210). Here, a code convention may refer to a coding style convention for writing code that is easy for workers to read and manage, and naming parameters and functions may also be included in the coding convention. For example, code conventions may include camel case, Pascal notation, Hungarian notation, and snake notation.

In other words, the server 100 can obtain a plurality of source codes that have been completed with the same style convention. For example, the server 100 may obtain a plurality of completed source codes from a database server that stores a plurality of completed codes, libraries, etc. For another example, the server 100 may obtain a plurality of completed source codes from an external server that provides open source.

The server 100 can recognize the function in each of the plurality of source codes and recognize the parameters constituting the function (S220). Additionally, the server 100 may recognize the structure of the function and the name of the function, and train the second neural network model using training data that labels the structure of the function with the name of the function (S230). In addition, the server 100 recognizes the positions and names of the parameters constituting the function, and creates a first neural network model using learning data that labels the names of the parameters in the positions of the parameters constituting the function. It can be learned (S240).

The first neural network model of the present invention may be a multi-classification model that performs a prediction probability determination function for each parameter name class. Here, the number of parameter name classes may correspond to the number of parameter name types recognized in a plurality of completed source codes, but is not limited to this.

Additionally, the second neural network model may be a multi-classification model that performs a function of determining prediction probability for each function name class. Here, the number of function name classes may correspond to the number of parameter name types recognized in a plurality of completed source codes, but is not limited to this.

Each of the first neural network model and the second neural network model of the present invention is CNN or R-CNN (Region based CNN), C-RNN (Convolutional Recursive Neural Network), Fast R-CNN, Faster R-CNN, and R-FCN (Region based CNN). based Fully Convolutional Network), YOLO (You Only Look Once), or SSD (Single Shot Multibox Detector) structures.

Hereinafter, activation functions related to the first neural network and the second neural network will be described with reference to FIG. 9.

Figure 9 is a schematic diagram showing one or more activation functions related to one embodiment of the present invention.

A deep neural network (DNN) may refer to a neural network that includes multiple hidden layers in addition to an input layer and an output layer. Deep neural networks allow you to identify latent structures in data. In other words, it is possible to identify the potential structure of a photo, text, video, voice, or music (e.g., what object is in the photo, what the content and emotion of the text are, what the content and emotion of the voice are, etc.) . Deep neural networks include convolutional neural networks (CNN), recurrent neural networks (RNN), auto encoders, generative adversarial networks (GAN), and restricted Boltzmann machines (RBM). machine), deep belief network (DBN), Q network, U network, Siamese network, etc. The description of the deep neural network described above is only an example and the present invention is not limited thereto.

A neural network can be trained in at least one of supervised learning, unsupervised learning, and semi-supervised learning. Learning of a neural network is intended to minimize errors in output. In neural network learning, learning data is repeatedly input into the neural network, the output of the neural network and the error of the target for the learning data are calculated, and the error of the neural network is transferred from the output layer of the neural network to the input layer in the direction of reducing the error. This is the process of updating the weight of each node in the neural network through backpropagation. In the case of teacher learning, learning data in which the correct answer is labeled in each learning data is used (i.e., labeled learning data), and in the case of non-teacher learning, the correct answer may not be labeled in each learning data. That is, for example, in the case of teacher learning regarding data classification, the learning data may be data in which each learning data is labeled with a category. Labeled training data is input to the neural network, and the error can be calculated by comparing the output (category) of the neural network and the label of the training data. As another example, in the case of non-teachable learning for data classification, the error can be calculated by comparing the input training data with the neural network output. The calculated error is backpropagated in the reverse direction (i.e., from the output layer to the input layer) in the neural network, and the connection weight of each node in each layer of the neural network can be updated according to backpropagation. The amount of change in the connection weight of each updated node may be determined according to the learning rate. The neural network's calculation of input data and backpropagation of errors can constitute a learning cycle (epoch). The learning rate may be applied differently depending on the number of repetitions of the learning cycle of the neural network. For example, in the early stages of neural network training, a high learning rate can be used to increase efficiency by allowing the neural network to quickly achieve a certain level of performance, and in the later stages of training, a low learning rate can be used to increase accuracy.

In the learning of neural networks, the training data can generally be a subset of real data (i.e., the data to be processed using the learned neural network), and thus the error for the training data is reduced, but the error for the real data is reduced. There may be an incremental learning cycle. Overfitting is a phenomenon in which errors in actual data increase due to excessive learning on training data. For example, a phenomenon in which a neural network that learned a cat by showing a yellow cat fails to recognize that it is a cat when it sees a non-yellow cat may be a type of overfitting. Overfitting can cause errors in machine learning algorithms to increase. To prevent such overfitting, various optimization methods can be used. To prevent overfitting, methods such as increasing the learning data, regularization, or dropout, which omits some of the network nodes during the learning process, can be applied.

Throughout this specification, activation function, computational model, neural network, network function, and neural network may be used interchangeably. (Hereinafter, it is described collectively as a neural network.) The data structure may include a neural network. And the data structure including the neural network may be stored in a computer-readable medium. Data structures including neural networks may also include data input to the neural network, weights of the neural network, hyperparameters of the neural network, data obtained from the neural network, activation functions associated with each node or layer of the neural network, and loss functions for learning the neural network. there is. A data structure containing a neural network may include any of the components disclosed above. In other words, the data structure including the neural network includes all or all of the data input to the neural network, the weights of the neural network, the hyperparameters of the neural network, the data acquired from the neural network, the activation function associated with each node or layer of the neural network, and the loss function for training the neural network. It may be configured to include any combination of. In addition to the configurations described above, a data structure containing a neural network may include any other information that determines the characteristics of the neural network. Additionally, the data structure may include all types of data used or generated in the computational process of a neural network and is not limited to the above. Computer-readable media may include computer-readable recording media and/or computer-readable transmission media. A neural network can generally consist of a set of interconnected computational units, which can be referred to as nodes. These nodes may also be referred to as neurons. A neural network consists of at least one node.

The data structure may include data input to the neural network. A data structure containing data input to a neural network may be stored in a computer-readable medium. Data input to the neural network may include learning data input during the neural network learning process and/or input data input to the neural network on which training has been completed. Data input to the neural network may include data that has undergone pre-processing and/or data subject to pre-processing. Preprocessing may include a data processing process to input data into a neural network. Therefore, the data structure may include data subject to preprocessing and data generated by preprocessing. The above-described data structure is only an example and the present invention is not limited thereto.

The data structure may include the weights of the neural network. (In this specification, weights and parameters may be used with the same meaning.) And the data structure including the weights of the neural network may be stored in a computer-readable medium. A neural network may include multiple weights. Weights may be variable and may be varied by the user or algorithm in order for the neural network to perform the desired function. For example, when one or more input nodes are connected to one output node by respective links, the output node is set to the values input to the input nodes connected to the output node and the links corresponding to each input node. The output node value can be determined based on the parameters. The above-described data structure is only an example and the present invention is not limited thereto.

As an example and not a limitation, the weights may include weights that are changed during the neural network learning process and/or weights for which neural network learning has been completed. Weights that change during the neural network learning process may include weights that change at the start of the learning cycle and/or weights that change during the learning cycle. Weights for which neural network training has been completed may include weights for which a learning cycle has been completed. Therefore, the data structure including the weights of the neural network may include weights that are changed during the neural network learning process and/or the data structure including the weights for which neural network learning has been completed. Therefore, the above-mentioned weights and/or combinations of each weight are included in the data structure including the weights of the neural network. The above-described data structure is only an example and the present invention is not limited thereto.

The data structure including the weights of the neural network may be stored in a computer-readable storage medium (e.g., memory, hard disk) after going through a serialization process. Serialization can be the process of converting a data structure into a form that can be stored on the same or a different computing device and later reorganized and used. Computing devices can transmit and receive data over a network by serializing data structures. Data structures containing the weights of a serialized neural network can be reconstructed on the same computing device or on a different computing device through deserialization. The data structure including the weights of the neural network is not limited to serialization. Furthermore, the data structure including the weights of the neural network is a data structure to increase computational efficiency while minimizing the use of computing device resources (e.g., in non-linear data structures, B-Tree, Trie, m-way search tree, AVL tree, Red-Black Tree) may be included. The foregoing is only an example and the present invention is not limited thereto.

The data structure may include hyper-parameters of a neural network. And the data structure including the hyperparameters of the neural network can be stored in a computer-readable medium. A hyperparameter may be a variable that can be changed by the user. Hyperparameters include, for example, learning rate, cost function, number of learning cycle repetitions, weight initialization (e.g., setting the range of weight values subject to weight initialization), Hidden Unit. It may include a number (e.g., number of hidden layers, number of nodes in hidden layers). The above-described data structure is only an example and the present invention is not limited thereto.

Above, embodiments of the present invention have been described with reference to the attached drawings, but those skilled in the art will understand that the present invention can be implemented in other specific forms without changing its technical idea or essential features. You will be able to understand it. Therefore, the embodiments described above should be understood in all respects as illustrative and not restrictive.

Claims (8)

In a method performed by a processor of a server,
Recognizing in real time a first source code including at least one undefined identifier input from a user terminal;
Inputting the first source code into a function-name matching score calculation model and providing recommended parameter names and recommended variable names related to the at least one undefined identifier to the user terminal;
Receive a first selection input for selecting one of the recommended parameter name and the recommended variable name from the user terminal, and generate a second source code in which the at least one identifier is defined based on the first selection input. steps;
Inputting the second source code into the function-name matching score calculation model and providing a recommended function name related to the at least one identifier to the user terminal; and
A third source code that receives a second selection input for selecting one of the recommended function names from the user terminal, and defines the at least one identifier and a function name related to the at least one identifier based on the second selection input. generating a;
Including,
The function-name matching score calculation model is,
Re-learned based on at least one of the first selection input and the second selection input,
How to automatically change the names of functions and parameters.
According to claim 1,
The function-name matching score calculation model is,
Based on the context-based Dynamic Code Analysis technique that analyzes the context and flow of the input code to understand the function of the input code, it includes the function of the code and the meaning corresponding to the function. Learned using training data labeled with an identifier,
How to automatically change the names of functions and parameters.
According to claim 1,
The function-name matching score calculation model is,
Prints the function-name matching score,
The function-name matching score is,
As the function-name match score calculation model converts and analyzes the input code into a code that has only the function excluding the identifier, a numeric value is calculated along with the function and an identifier containing the meaning corresponding to the function,
How to automatically change the names of functions and parameters.
According to clause 3,
Inputting the first source code into the function-name matching score calculation model to provide a recommended parameter name and a recommended variable name related to the at least one undefined identifier to the user terminal,
providing the function-name matching score corresponding to each of the recommended parameter name and the recommended variable name; and
providing a number of selection times for each of the recommended parameter name and the recommended variable name selected to date for each of the at least one undefined identifier;
Including,
Based on the first selection input, the number of selections is updated,
How to automatically change the names of functions and parameters.
According to claim 1,
The above method is,
Recognizing whether a variable or parameter that must exist in a specific function included in the first source code does not exist based on the function-name matching score calculation model; and
When it is recognized that the variable or parameter that must exist in the specific function does not exist, recommending an identifier corresponding to the missing variable or missing parameter;
Containing more,
How to automatically change the names of functions and parameters.
According to claim 1,
The above method is,
If the first selection input for selecting one of the recommended parameter name and the recommended variable name is not received and a manually input identifier is received, evaluating the manually input identifier; and
labeling the manually entered identifier and a function of a code corresponding to the manually entered identifier, and retraining the function-name matching score calculation model;
Containing more,
How to automatically change the names of functions and parameters.
A memory that stores one or more instructions; and
A processor that executes the one or more instructions stored in the memory
Contains,
The processor executes the one or more instructions,
An apparatus for performing the method of claim 1.
A computer program combined with a computer as hardware and stored on a computer-readable recording medium so as to perform the method of claim 1.