Monitoring application code usage for improved implementation of reusable code

A code tracking system monitors usage of application code executed by one or more computing devices. Characteristics of the usage of the application code are determined. Using the characteristics of the usage of the application code, a modification to an entry of application code executed by the one or more computing devices is detected. The detected modification to the entry of application code is communicated to a code management system. The code management system presents the modification to the entry of the application code to a user of the code management system.

TECHNICAL FIELD

The present disclosure relates generally to managing application code. More particularly, in certain embodiments, the present disclosure is related to monitoring application code usage for improved implementation of reusable code.

BACKGROUND

Programming code is presented in a human-readable programming language (e.g., as opposed to binary machine code). A given program, or computing task, may be implemented using the code. Specialized training and knowledge of a code's programming language is generally required to both understand the function(s) of a given piece of code and to create new code using the original code as a starting point to perform a desired task.

SUMMARY

This disclosure encompasses the recognition of previously unidentified problems associated with previous technology used to reuse application code. For instance, previous approaches to reusing application code generally relied on developers' attempts to understand and repurpose stored code, which may be poorly annotated and/or optimized for a different use than that of interest to the developers. For example, different developers often have different approaches to writing code, resulting in code entries being stored for reuse in a form which, in the absence of improvements like those described in this disclosure, is of limited use to others. Using previous technology, multiple copies of the same or similar source code may be stored that perform the same function, resulting in inefficient use of computing resources. Previous technology fails to provide any indication of which code entries for a particular purpose may be the most effective (e.g., based on previous usage) and provide the best user experience. Moreover, using previous technology, developers that provide code for reuse by others are not provided tools for improving their code over time.

Certain embodiments of this disclosure provide unique solutions to technical problems of previous technology, including those described above, by providing the practical application of code management and tracking systems. For example, the disclosed systems provide several technical advantages which may include 1) the ability to identify and implement reusable code for a user's desired purpose via an intuitive and user-friendly graphical user interface; 2) the ability to track changes to reusable code that has been deployed such that any improvements to the code can be captured and provided to other deployments of the code; and 3) a platform that motivates developers to provide and maintain high quality code for reuse by others. As such, this disclosure may improve the function of computer systems used for storing, deploying, and updating application code for reuse by a number of users.

In some embodiments, the systems, methods, and devices described in this disclosure may particularly be integrated into a practical application of a code management system that provides a user interface that allows a user to select requested features of desired application code and/or provide a request for code and receive a corresponding set of one or more candidate code entries. A selected code entry may be stored to the user's device. In some cases, a value may be associated with the code entries and presented alongside the candidate entries. The value may correspond to an amount of resources needed to implement the code, such that the user may more effectively select code that meets both coding needs and any resource constraints.

In some embodiments, the systems, methods, and devices described in this disclosure may particularly be integrated into a practical application of a code execution tracking system that monitors the usage of reusable code that is deployed. The code execution tracking system may detect that deployed code is changed. The changed code may be presented to the original code developer, such that any improvements can be implemented in the centrally stored code that is offered as reusable code to other users. The code execution tracking system may use the monitored code usage to determine a value of the code (e.g., a metric corresponding to how many users are using the code, how many work functions are performed with the code, etc.). The code value may be used to appropriately reward the code's developer(s) and/or update the amount or number of resources needed to use the code.

In an embodiment, a system includes a code repository configured to store application code. Each entry of application code includes instructions in a programming language for performing a computing task. For each entry of application code, the code repository also includes metadata indicating a purpose associated with the computing task performed by the application code. A code management system includes a memory operable to store instructions for presenting a graphical user interface to a user. The code management system includes a processor communicatively coupled to the memory. The code management system presents the graphical user interface, which includes fields for selection of requested features of application code requested by the user. The code management system determines, based at least in part on the requested features selected in the graphical user interface, code requirements that include attributes of application code needed to achieve the requested features. The code management system determines, based at least in part on the determined code requirements and the metadata for each entry of application code stored in the code repository, one or more candidate application code entries from the code repository. The code management system presents the candidate application code entries for user selection in the graphical user interface. After receipt of a user selection of a selected application code, the selected application code is provided to a computing device associated with the user.

In yet another embodiment, a system includes one or more computing devices executing application code that includes instructions in a programming language for performing a computing task. A code tracking system monitors usage of the application code executed by the one or more computing devices. Characteristics of the usage of the application code are determined based on the monitored usage of the application code. The characteristics include one or more of a frequency of usage of the application code, a number of users of the application code, a record of computing tasks performed using the application code. Using the characteristics of the usage of the application code, a modification to an entry of application code executed by the one or more computing devices is detected. The detected modification to the entry of application code is communicated to a code management system. The code management system presents the modification to the entry of the application code to a user of the code management system.

DETAILED DESCRIPTION

As described above, prior to this disclosure, there was a lack of tools for reliably reusing application code. The disclosed systems, described with respect to the examples ofFIGS.1-4below, provide solutions to the problems of previous technology. The disclosed systems may store reusable code more efficiently, such that unnecessary resources are not wasted for repeated code for the same the functions or for functions not requested by users and such that that the most effective code is reused more frequently. The disclosed systems may facilitate updating stored code for improved reusability, such that modifications leading to improvements can be used to update deployed instances of the code when appropriate. The disclosed systems may further motivate developers of code to generate code that is more readily reusable by tracking how reusable code is used by other users.

As used in this disclosure, a natural language corresponds to a an established language (e.g., English) used for human-to-human communication. As used in the disclosure, a programming language refers to a formalized text-based language which includes instructions for implementing functions and/or tasks using a computer. Examples of programming languages include C, C++, C #, Python, JAVA, HTML, and the like. These programming languages are provided for example only. This disclosure contemplates the use of any programming language.

Code Management System for Improved Code Deployment

FIG.1is a schematic diagram of an example system100for code management and deployment. The system100includes a code repository102, code sources116, code management system120, one or more code execution devices154, and an optional execution tracking system302(seeFIG.3). The code management system120of system100is generally configured to determine one or more entries of candidate code148that meet the needs of a user136to perform a desired task (e.g., that correspond to needs indicated in a request140and/or entered via entry/selection138of code features130,132,134in a graphical user interface (GUI)128). The user136can then select an entry of candidate code148(e.g., via selection/approval152), and the selected code162is automatically deployed to a code execution device154associated with the user136(e.g., such that the user136can use the selected code162for some purpose). After the selected code162is deployed, the execution tracking system302may monitor how the selected code162(or other deployed code) is used.FIG.3illustrates the structure and function of an example execution tracking system302in greater detail.

The code repository102is generally a data store, or database, configured to store executable code110along with corresponding purpose metadata112and values114. The code repository102generally includes a processor104, memory106, and network interface108. The processor104of the code repository102includes one or more processors. The processor104is any electronic circuitry including, but not limited to, state machines, one or more central processing unit (CPU) chips, logic units, cores (e.g. a multi-core processor), field-programmable gate array (FPGAs), application specific integrated circuits (ASICs), or digital signal processors (DSPs). The processor104may be a programmable logic device, a microcontroller, a microprocessor, or any suitable combination of the preceding. The processor104is communicatively coupled to and in signal communication with the memory106and network interface108. The one or more processors are configured to process data and may be implemented in hardware and/or software. For example, the processor104may be 8-bit, 16-bit, 32-bit, 64-bit or of any other suitable architecture. The processor104may include an arithmetic logic unit (ALU) for performing arithmetic and logic operations, processor registers that supply operands to the ALU and store the results of ALU operations, and a control unit that fetches instructions from memory106and executes them by directing the coordinated operations of the ALU, registers and other components.

The memory106of the code repository102is operable to store executable code110, purpose metadata112, values114, and any data, instructions, logic, rules, or code operable to execute the functions of the code repository102. The memory106includes one or more disks, tape drives, or solid-state drives, and may be used as an over-flow data storage device, to store programs when such programs are selected for execution, and to store instructions and data that are read during program execution. The memory106may be volatile or non-volatile and may include read-only memory (ROM), random-access memory (RAM), ternary content-addressable memory (TCAM), dynamic random-access memory (DRAM), and static random-access memory (SRAM).

The network interface108of the code repository102is configured to enable wired and/or wireless communications. The network interface108is configured to communicate data between the code repository102and other network devices, systems, or domain(s), such as code sources116and the code management system120. The network interface108is an electronic circuit that is configured to enable communications between devices. For example, the network interface108may include one or more serial ports (e.g., USB ports or the like) and/or parallel ports (e.g., any type of multi-pin port) for facilitating this communication. As a further example, the network interface108may include a WIFI interface, a local area network (LAN) interface, a wide area network (WAN) interface, a modem, a switch, or a router. The processor104is configured to send and receive data using the network interface108. The network interface108may be configured to use any suitable type of communication protocol as would be appreciated by one of ordinary skill in the art. The network interface108receives executable code110from code sources116and communicates executable code110, purpose metadata112, and values114to the code management system120.

Each entry of executable code110stored in the memory106generally includes instructions in a programming language for performing one or more computing tasks. The executable code110may be obtained from one or more code sources116, which may include public code repositories (e.g., of open source executable code110) and/or private code repositories associated with different work groups, or the like, within the organization operating the system100. As an example, a developer118at the organization may generate executable code110for a given project or purpose and store the executable code110in a data source116providing storage for the developers' workgroup, organization, or the like.

The purpose metadata112generally indicates an underlying purpose or use of each entry of executable code110. For example, the purpose metadata112may indicate a purpose associated with a computing task performed by the code110. For instance, purpose metadata112may identify a group that commonly uses the code110, an organization or workgroup in an organization that uses the code110, types of analyses performed with the code110, and the like. The purpose metadata112may be determined, at least in part, using information provided by the developer118at the time the executable code110is originally stored at a code source116or the code repository102. In some cases, at least a portion of the purpose metadata112is determined by the code repository102. For example, the code repository102may access the executable code110and detect functions employed by the executable code110, a programming language of the executable code110, and/or explanatory annotations presented in the executable code110(e.g., text included in the executable code110that is not related to program functionality but instead provides a natural language description of functions of the executable code110).

The values114generally indicate, for each entry of executable code110, a predefined value associated with the code110. For example, a value114may correspond to an amount of resources (e.g., memory, processing power, network bandwidth, software licenses, etc.) needed to use a corresponding entry of code110. As another example, a value114may correspond to a reward provided to a developer118when the code110is reused by others.

The code management system120is in communication with the code repository102and the code execution device(s)154(e.g., via network interface126). The code management system120determines one or more entries of candidate code148that meet the needs of a user136to perform a desired task (e.g., that correspond to needs indicated in a request140and/or entered via entry/selection138of code features130,132,134in the GUI128). The user136can then select an entry of candidate code148(e.g., via selection/approval152), and the selected code162is automatically deployed to an appropriate device154associated with the user136(e.g., such that the user136can use the selected code162for some purpose).

The code management system120generally includes a processor122, memory124, and network interface126. The processor122of the code management system120includes one or more processors. The processor122is any electronic circuitry including, but not limited to, state machines, one or more central processing unit (CPU) chips, logic units, cores (e.g. a multi-core processor), field-programmable gate array (FPGAs), application specific integrated circuits (ASICs), or digital signal processors (DSPs). The processor122may be a programmable logic device, a microcontroller, a microprocessor, or any suitable combination of the preceding. The processor122is communicatively coupled to and in signal communication with the memory124and network interface126. The one or more processors are configured to process data and may be implemented in hardware and/or software. For example, the processor122may be 8-bit, 16-bit, 32-bit, 64-bit or of any other suitable architecture. The processor122may include an arithmetic logic unit (ALU) for performing arithmetic and logic operations, processor registers that supply operands to the ALU and store the results of ALU operations, and a control unit that fetches instructions from memory124and executes them by directing the coordinated operations of the ALU, registers and other components.

The memory124of the code management system120is operable to store GUI presentation instructions128a, metadata mapping instructions142a, and any data, instructions, logic, rules, or code operable to execute the functions of the code management system120. The GUI presentation instructions128ainclude any code, logic, or rules for presenting the GUI128to user136. The metadata mapping instructions142agenerally includes any code, logic, or rules for performing metadata mapping142(described further below). For example, the metadata mapping instructions142amay include instructions for performing natural language processing (NLP)144in order to determine a meaning of a request140provided by user136. The memory124includes one or more disks, tape drives, or solid-state drives, and may be used as an over-flow data storage device, to store programs when such programs are selected for execution, and to store instructions and data that are read during program execution. The memory124may be volatile or non-volatile and may include read-only memory (ROM), random-access memory (RAM), ternary content-addressable memory (TCAM), dynamic random-access memory (DRAM), and static random-access memory (SRAM).

The network interface126of the code management system120is configured to enable wired and/or wireless communications. The network interface126is configured to communicate data between the code management system120and other network devices, systems, or domain(s), such as the code repository102and the code execution devices154. The network interface126is an electronic circuit that is configured to enable communications between devices. For example, the network interface126may include one or more serial ports (e.g., USB ports or the like) and/or parallel ports (e.g., any type of multi-pin port) for facilitating this communication. As a further example, the network interface126may include a WIFI interface, a local area network (LAN) interface, a wide area network (WAN) interface, a modem, a switch, or a router. The processor122is configured to send and receive data using the network interface126. The network interface126may be configured to use any suitable type of communication protocol as would be appreciated by one of ordinary skill in the art. The network interface126receives executable code110, purpose metadata112, and values114from the code repository102, user inputs to the GUI128(e.g., selection138, request140, selection/approval152, etc.), and communicates selected code162to the code execution devices154.

The code management system120presents the GUI128for viewing by a user136that is seeking code110to reuse. The GUI128may be presented on a display of a device operated by the user136(e.g., a code execution device154), the code management system120, or another device. The GUI128includes fields for entering features130,132,134that the user136requests to be included in the code110for which the user136is searching. For example, the user136may provide a selection138of features130,132,134. For example, language feature130may correspond to an indication of an application programming language of the code110requested by the user136. Type feature132may correspond to an indication of a type of the code110requested by the user136. Task feature134may correspond to an indication of a computing task to be performed by the code110requested by the user136. The GUI128may include a field for entry of a request140from the user136. The request140may be entered in a natural language. As an example, request140entered in a corresponding GUI field may indicate further requested features of the code110desired by the user136. As described further below, a request140entered in a corresponding GUI field may be used, at least in part, to determine the candidate code148that is provided for user selection.

The requested code features (e.g., corresponding to selections138of features130,132,134and/or request140) that are provided by the user136in the GUI128are then used to perform metadata mapping142. Metadata mapping142generally involves the determination of code requirements146, which are the attributes of the code110needed to meet the user's needs. The code requirements146may include required features, properties, and/or abilities of the entries of candidate code148that will be presented for user selection. For example, the code requirements146may include requirement that candidate code148use the programming language indicated in language feature130, are the same type as indicated by the type feature132, and/or perform at least the same computing tasks as those indicated by the task feature134. In cases where a request140is provided, metadata mapping142may use natural language processing (NLP)144(e.g., a natural language processing algorithm) to determine the code requirements146. For example, the code requirements146may be determined based at least in part on the natural language request140combined with any features130,132,134selected in the GUI128.

The code management system120uses the code requirements146to determine code110that should be presented as candidate code148for selection by the user136. For example, the code management system120may determine, based at least in part on the determined code requirements146and the purpose metadata112of each entry of code110, one or more entries of stored code110that should be included as candidate code148. For instance, entries of stored code110with purpose metadata112indicating that the code110satisfies the code requirements146may be included as candidate code148.

The code management system120present the entries of candidate code148for user selection in the GUI128. For example, a name and/or brief description or view of the candidate code148may be provided in the GUI128for the user136to review prior to providing a selection/approval152. In some cases, the code management system120may also present, in the GUI128, a predefined value150corresponding to each of the presented entries of candidate code148. The predefined value is generally the value114for each entry of stored code110that is included as candidate code148.

The user136may provide a selection or approval152of one or more of the presented entries of candidate code148. For example, the user136may click on an entry of candidate code148to review its use history, programmatic instructions, value150, and/or the like, and upon determining that the entry of candidate code148is appropriate for the user's needs, provide the selection/approval152of the candidate code148. After receipt of the selection/approval152, the corresponding selected code162is provided to a code execution device154associated with the user136. For example, the code management system120may automatically cause the selected code162to be stored in memory158of the user's code execution device154, as illustrated in the example ofFIG.1.

The code execution device(s)154are generally any computing devices operable to receive the selected code162and execute the selected code162to perform its corresponding functions. For example, each of the code execution device(s)154may be a computer, a mobile device, a personal assistant device, or the like. Each code execution device154includes a processor156, memory158, and network interface160. The processor156of the code execution device(s)154includes one or more processors. The processor156is any electronic circuitry including, but not limited to, state machines, one or more central processing unit (CPU) chips, logic units, cores (e.g. a multi-core processor), field-programmable gate array (FPGAs), application specific integrated circuits (ASICs), or digital signal processors (DSPs). The processor156may be a programmable logic device, a microcontroller, a microprocessor, or any suitable combination of the preceding. The processor156is communicatively coupled to and in signal communication with the memory158and network interface160. The one or more processors are configured to process data and may be implemented in hardware and/or software. For example, the processor156may be 8-bit, 16-bit, 32-bit, 64-bit or of any other suitable architecture. The processor156may include an arithmetic logic unit (ALU) for performing arithmetic and logic operations, processor registers that supply operands to the ALU and store the results of ALU operations, and a control unit that fetches instructions from memory158and executes them by directing the coordinated operations of the ALU, registers and other components.

The memory158of the code execution device(s)154is operable to store selected code162, and any data, instructions, logic, rules, or code operable to execute the functions of the code execution device(s)154. The memory158includes one or more disks, tape drives, or solid-state drives, and may be used as an over-flow data storage device, to store programs when such programs are selected for execution, and to store instructions and data that are read during program execution. The memory158may be volatile or non-volatile and may include read-only memory (ROM), random-access memory (RAM), ternary content-addressable memory (TCAM), dynamic random-access memory (DRAM), and static random-access memory (SRAM).

The network interface160of the code execution device(s)154is configured to enable wired and/or wireless communications. The network interface160is configured to communicate data between the code execution device(s)154and other network devices, systems, or domain(s), such as the code management system120and the execution tracking system302. The network interface160is an electronic circuit that is configured to enable communications between devices. For example, the network interface160may include one or more serial ports (e.g., USB ports or the like) and/or parallel ports (e.g., any type of multi-pin port) for facilitating this communication. As a further example, the network interface160may include a WIFI interface, a local area network (LAN) interface, a wide area network (WAN) interface, a modem, a switch, or a router. The processor156is configured to send and receive data using the network interface160. The network interface160may be configured to use any suitable type of communication protocol as would be appreciated by one of ordinary skill in the art. The network interface160receives selected code162and provides information to the execution tracking system302(seeFIGS.3and4and corresponding description below).

In some embodiments, the system100includes an execution tracking system302which monitors usage of the selected code162after it is deployed to the code execution device(s)154. Details of the configuration and operation of an example execution tracking system302are provided with respect toFIGS.3and4below. As a brief example, the execution tracking system302may detect modifications to the selected code162after it is provided to the code execution device(s) associated with the user136. These changes may be used to improve the executable code110stored in the code repository102and, in some cases, automatically provide improved code110to other code execution device(s)154, such that the most up-to-date or optimized code110is efficiently deployed.

In an example operation of the system100, a developer118stores executable code110in a code source116, such as a repository operated by the developer's workgroup. The code repository102detects this new executable code110and stores a copy of the executable code110in its memory106. The code repository102also generates purpose metadata112for the code110. For example, the code repository102may access the executable code110and detect functions employed by the executable code110, a programming language of the executable code110, and/or explanatory annotations presented in the executable code110(e.g., text included in the executable code110that is not related to program functionality but instead provides a natural language description of functions of the executable code110) to determine the purpose metadata112. The code repository102may determine a value114for the executable code110. For example, the value114may correspond to resources expended to use the code110and/or an incentive provided to the developer118if the code110is reused (e.g., via deployment to one or more of the code execution devices154).

At some later point in time, a user136accesses the GUI128presented by the code management system120and provides a selection138of requested code features130,132,134and/or a request140for code (e.g., in a natural language). The code management system120identifies code requirements146that correspond to the requested features indicated by the user's selection138(e.g., features130,132,134) and/or request140(e.g., using NLP144). The code requirements146are mapped, or compared, to the purpose metadata112of the stored code110to determine if any of the stored code110satisfies the code requirements146. Entries of the stored code110that satisfy the code requirements146(e.g., or at least a threshold amount of the code requirements146) may be presented as candidate code148in the GUI128along with the values150corresponding with the values114of the code110included as candidate code148.

After receiving a user selection/approval152of an entry of candidate code148, the candidate code148is provided to (e.g., installed or stored in memory158of) a code execution device154associated with the user136. The user136can then execute and/or modify the selected code162as needed for their purpose. As such, the code management system120provides the practical application of improving the reuse of stored code110.

In some cases, the execution tracking system302may monitor how the selected code162is used and/or changed over time. For example, usage of the selected code162may be used to update the values114of stored code110corresponding to the selected code162. For example, a value114may be increased for stored code110that has a higher usage when deployed in the code execution devices154. As another example, changes to the selected code162may be incorporated into the corresponding stored code110if the changes are beneficial for functionality, efficiencies, reliability, etc. If such a change is made, the updated stored code110may be automatically provided to code execution devices154that are using the old version of the code110. This ensures the most up-to-date and/or optimized code110is in use. Operations of the execution tracking system302are described in greater detail below with respect toFIGS.3and4.

FIG.2illustrates an example method200of operating the system100ofFIG.1. The method200may be integrated into the practical application of improving the identification of reusable code110for a given user's needs, such that stored code110is effectively deployed for use in a more reliable and efficient manner than was possible using previous technology. Method200may begin at step202where instructions128a,142aare stored in the memory124of the code management system120. At step204, the GUI128is presented to a user136that is seeking to reuse an entry of executable code110stored in the code repository102. The GUI128is described with respect toFIG.1above.

At step206, the code management system120receives (e.g., via the GUI128) selection138and/or request140corresponding to requested features of code110sought by the user136. For example, the requested features indicated by the selection138and/or request140may include indication of an application programming language of the code110requested by the user136via the language feature130, an indication of a type of the code110requested by the user136via the type feature132, and/or an indication of a computing task to be performed by the code110requested by the user136via the task feature134.

At step208, the code management system120determines the code requirements146. For example, the code management system120may perform metadata mapping142as described above with respect toFIG.1. In brief, the code management system120may use natural language processing144to determine requested properties in the user request140. These properties may be used in combination with those provided via user selection138of features130,132,134in the GUI128to determine the code requirements146.

At step210, the code management system120determines whether candidate code148is identified that corresponds to stored code110that satisfies the code requirements146determined at step208. The purpose metadata112may be used to determine whether various entries of the stored code110satisfy the code requirements146, as described above with respect toFIG.1. If no candidate code148is identified, the code management system120may proceed to step212and provide an indication that no code110is available for the user's needs. In such cases, the code management system120may optionally prompt or remind the user136to provide any code that is developed by the user136for storage in the code repository102, such that reusable code110will become available for this purpose that is currently not covered by the available collection of stored code110. Otherwise, if at least one entry of candidate code148is identified at step210, the code management system120proceeds to step214.

At step214, the code management system120presents the candidate code148determined at step210for presentation to the user136. At step216, values150corresponding to the entries of candidate code148may be presented. As described above with respect toFIG.1, the values150may correspond to an amount of resources required to use the candidate code148. Through presentation of values150, a user136can make a more informed selection of candidate code148that matches with their available resources.

At step218, the code management system120determines whether a selection/approval152of an entry of candidate code148is received. Is a selection/approval152is not received, the code management system120eventually ends the method200(e.g., after waiting a predefined period of time for a user selection/approval152). Otherwise, if a user selection/approval152is received, the code management system120proceeds to step220.

At step220, the code management system120provides the candidate code148selected at step218to a code execution device154associated with the user136. For example, the selected code162may be installed on or stored in memory158of the code execution device154. At step222, the execution tracking system302may begin tracking usage and/or changes to the selected code162, as described in greater detail with respect toFIGS.3and4below.

Code Tracking for Continuous Code Monitoring and Improvement

FIG.3is a schematic diagram of an example system300for tracking usage of and changes to deployed code314. In some cases, deployed code314may be selected code162described above with respect toFIGS.1and2. The system300may include a code repository102, code sources116, and a code management system120that are the same as or similar to those described above with respect toFIGS.1and2. The system300also includes a code management system120, one or more code execution devices154, and an execution tracking system302. In some embodiments, the code management system120and code execution devices154are configured to perform the functions described above with respect toFIGS.1and2in addition to those described below with respect toFIGS.3and4. The execution tracking system302generally monitors the usage of deployed code314. Usage characteristics316of the deployed code314may be used to identify code modifications332that provide performance improvements and/or adjusted code values326corresponding to resources required to use the deployed code314. This information from the execution tracking system302may be presented to a developer118responsible for the deployed code314(e.g., that created and/or maintains the deployed code314). If the code value326and/or code modifications332are approved by the developer118, these changes may be made at the code repository102via automatic update338(e.g., to adjust the code110, purpose metadata112, and/or values114). This update338and/or any other update(s)340may be automatically propagated to other instances of the deployed code314used by other code execution devices154. This ensures that the most up-to-date and optimized code110is able to be efficiently and reliably available to code execution devices154.

The execution tracking system302includes a processor304, memory306, and network interface308. The processor304of the execution tracking system302includes one or more processors. The processor304is any electronic circuitry including, but not limited to, state machines, one or more central processing unit (CPU) chips, logic units, cores (e.g. a multi-core processor), field-programmable gate array (FPGAs), application specific integrated circuits (ASICs), or digital signal processors (DSPs). The processor304may be a programmable logic device, a microcontroller, a microprocessor, or any suitable combination of the preceding. The processor304is communicatively coupled to and in signal communication with the memory306and network interface308. The one or more processors are configured to process data and may be implemented in hardware and/or software. For example, the processor304may be 8-bit, 16-bit, 32-bit, 64-bit or of any other suitable architecture. The processor304may include an arithmetic logic unit (ALU) for performing arithmetic and logic operations, processor registers that supply operands to the ALU and store the results of ALU operations, and a control unit that fetches instructions from memory306and executes them by directing the coordinated operations of the ALU, registers and other components.

The memory306of the execution tracking system302is operable to store instructions310that include any data, logic, rules, or code operable to execute the functions of the execution tracking system302. The memory306includes one or more disks, tape drives, or solid-state drives, and may be used as an over-flow data storage device, to store programs when such programs are selected for execution, and to store instructions and data that are read during program execution. The memory306may be volatile or non-volatile and may include read-only memory (ROM), random-access memory (RAM), ternary content-addressable memory (TCAM), dynamic random-access memory (DRAM), and static random-access memory (SRAM).

The network interface308of the execution tracking system302is configured to enable wired and/or wireless communications. The network interface308is configured to communicate data between the execution tracking system302and other network devices, systems, or domain(s), such as the code management system120, code execution device(s)154, and code repository102. The network interface308is an electronic circuit that is configured to enable communications between devices. For example, the network interface308may include one or more serial ports (e.g., USB ports or the like) and/or parallel ports (e.g., any type of multi-pin port) for facilitating this communication. As a further example, the network interface308may include a WIFI interface, a local area network (LAN) interface, a wide area network (WAN) interface, a modem, a switch, or a router. The processor304is configured to send and receive data using the network interface308. The network interface308may be configured to use any suitable type of communication protocol as would be appreciated by one of ordinary skill in the art. The network interface308receives information about deployed code314, modified code328, and/or updated code342and communicates usage characteristics316, code values326, and code modifications332, as described in greater detail below.

For the purposes of illustrating operation of the execution tracking system302, different functions are illustrated as being performed by a usage monitor312, tracking utility324, and improvement utility330. It should be understood that the functions and operations of each of these components are performed by the processor304executing instructions310stored in the memory306. Operations involving communication with other systems or devices may be performed using the network interface308.

The usage monitor312monitors deployed code314and determines usage characteristics316of the deployed code314. The deployed code314is generally any programming code executed by a code execution device154. Generally, deployed code314that is monitored by the execution tracking system302corresponds to an entry of code110stored in the code repository102. The usage characteristics316may include a frequency318of usage of the deployed code314(e.g., how often the deployed code314is used in a given period of time), user characteristics320of users136of the deployed code314(e.g., a number of users136of the deployed code314), a record of computing tasks322performed using the deployed code314(e.g., types of work, types of analyses, etc. performed using the deployed code314).

The tracking utility324may use the usage characteristics316to determine a code value326for the deployed code314. The code value326may be a metric of usage of the deployed code314. For example, deployed code314that, based on the usage characteristics316, requires a relatively large number or amount of resources (e.g., usage of processor156, memory158, and/or network interface160) may have an increased code value326. In some cases, the code value326may correspond to a metric for how reusable the deployed code314is based on the usage characteristics. For example, deployed code314with a high frequency318of use, a large number of users320, and/or that is used for a large number of tasks322(e.g., or for critical tasks322) may be determined to have an increased code value326. The code value326may be used to adjust how a developer118is rewarded for creating and/or maintaining stored code110that corresponds to the deployed code314.

The execution tracking system302may communicate the determined code value326, alone or together with at least a portion of the usage characteristics316, for presentation to the developer118. For example, the code value326and/or usage characteristics316may be provided to the code management system120. The code management system120may present a GUI334that provides a presentation of the code value326and/or usage characteristics316. The GUI presentation instructions128adescribed with respect toFIG.1above may include instructions for presenting the GUI334illustrated inFIG.3. In some cases, the code value326and/or usage characteristics316for a given entry of deployed code314that was created and/or is maintained by the developer118may be presented in response to a status request336provided by the developer118. The memory124of the code management system120may store the code value326and/or usage characteristics316. If the code value326is changed from an original value114for the entry of stored code110that corresponds to the deployed code314, the code management system120may provide an automatic update338that changes the value114to the determined code value326. The updated value114may provide future users136a more accurate and up-to-date metric of the resources needed to use the stored code110.

In some cases, a user136may make one or more changes to deployed code314, thereby generating modified code328. The execution tracking system302can detect such changes and use the improvement utility330to determine code modifications332that were made to arrive at the modified code328from the original deployed code314. For example, the improvement utility330may detect, using the usage characteristics316, a code modification332to a given entry of deployed code314. The code modification332may correspond to a change to the instructions in the programming language of the entry of the deployed code314. For example, the detected change may alter at least a portion of a computing task performed by the entry of the deployed code314.

The execution tracking system302may communicate the detected code modification332, alone or together with at least a portion of the usage characteristics316for presentation to the developer118. For example, the code modification332and/or usage characteristics316may be provided to the code management system120. The code management system120may present the GUI334that provides a presentation of the code modifications332and/or usage characteristics316. In some cases, the code modifications332and/or usage characteristics316for a given entry of deployed code314that was created and/or is maintained by the developer118may be presented in response to a status request336provided by the developer118. The memory124may store the code modifications332.

In some cases, the code management system120may automatically update the code110stored in the code repository102that corresponds to the entry of deployed code314that was modified. For example, an entry of stored code110corresponding to an original deployed code314may be changed to be the same as modified code328. The developer118may indicate an approval of the modified code328if the changes introduced by user136improve functioning of the original deployed code314. As such, continuous improvements to the stored code110can be achieved in the system300ofFIG.3. The developer118can also view the code modifications332and provide their own update340to the stored code110if desired. After stored code110is updated via update338and/or update340, the update(s)338,340may be automatically propagated to the other code execution devices154to replace deployed code314(e.g., such that stored copies of a previous version of the deployed code314are replaced by the updated code110). As such, the improved code110can be efficiently and reliably provided to other code execution devices154, such that improvements are realized by others.

FIG.4illustrates an example method400of operating the system300ofFIG.1. The method400may be integrated into the practical application of improving the stored code110, such that stored code110is efficiently and reliably updated based on how corresponding deployed code314is used. Method400may begin at step402where the execution tracking system302monitors usage of deployed code314. For example, the execution tracking system302may detect when each instance of deployed code314is executed and a usage context of the deployed code314(e.g., which organizational unit, user136, or the like is using the deployed code314).

At step404, the execution tracking system302determines usage characteristics316of the deployed code314. The usage characteristics316may include a frequency318of usage of the deployed code314(e.g., how often the deployed code314is used in a given period of time), user characteristics320of users136of the deployed code314(e.g., a number of users136of the deployed code314), a record of computing tasks322performed using the deployed code314(e.g., types of work, types of analyses, etc. performed using the deployed code314).

At step406, the execution tracking system302determines whether a code modification332is detected. For example, the improvement utility330may detect, using the usage characteristics316, a code modification332to a given entry of deployed code314. The code modification332may correspond to a change to the instructions in the programming language of the entry of the deployed code314, as described with respect toFIG.3above. If a code modification332is not detected, the execution tracking system302proceeds to step414. However, if a code modification332is detected (e.g., if modified code328is detected), the execution tracking system302proceeds to step408.

At step408, the code modification332is provided for presentation. For example, the execution tracking system302may provide the code modification332to the code management system120, which uses GUI334to present the code modification332to developer118, as described with respect toFIG.3above.

At step410, stored code110corresponding to the deployed code314that was modified is automatically updated (e.g., by replacing the stored code110with the modified code328). In some cases, the developer may provide an update340, such that the updated stored code110is not necessarily identical to the modified code328but still includes at least a portion of improvements that appear in the modified code328.

At step412, the updated stored code110from step410is automatically propagated to the code execution devices154. For example, updated stored code110may be automatically propagated to the other code execution devices154to replace deployed code314(e.g., such that stored copies of a previous version of the deployed code314are replaced by the updated code110). As such, the improved code110can be efficiently and reliably provided to other code execution devices154, as described above with respect toFIG.3.

At step414, a code value326may be determined for an entry of deployed code314. The code value326may be determined using the usage characteristics316. For example, the code value326may be determined as a value that is scaled according to the frequency318of usage of deployed code, user characteristics320associated with the deployed code314, and/or tasks322performed using the deployed code314. The code value326is generally a metric of usage of the deployed code314and/or resources needed to execute the deployed code314.

At step416, the code value326is provided for presentation. For example, the execution tracking system302may provide the code value326to the code management system120, which uses GUI334to present the code value326to developer118, as described with respect toFIG.3above. At step418, the value114for stored code110may be updated based on the code value326. For example, the code management system120may provide an automatic update338that changes the value114to the determined code value326. The updated value114may provide future users136a more accurate and up-to-date metric of the resources needed to use the stored code110.