Patent Application
20230140791
The present invention relates to programming task execution, and more specifically to generating cross-industry supporting material for a programming task to be executed.
According to an embodiment of the present invention, a computer-implemented method is described. According to the method, a programming task to be executed is received. A system identifies, from a database of completed tasks, a completed task that is similar to the programming task to be executed. The system extracts supporting documentation associated with the completed task that is similar to the programming task to be executed and generates and transmits supporting material associated with the completed task to a computing device to execute the programming task.
The present specification also describes a system. The system includes a database of completed programming tasks and associated supporting documentation per completed programming task. A cross-ontology handler of the system identifies from completed tasks in the database, terms that are different but similar to terms in the programming task to be executed. A task similarity analyzer of the system identifies, from the database, a completed task that is similar to a programming task to be executed. A document extractor extracts supporting documentation associated with the completed task that is similar to the programming task to be executed. The system also includes a supporting material generator to generate supporting material associated with the completed task to a computing device to execute the programming task. A semantic analyzer semantically analyzes a deliverable associated with the programming task to be executed.
The present specification also describes a computer program product. The computer program product includes a computer readable storage medium having program instructions embodied therewith. The program instructions are executable by a processor, to cause the processor to: receive, by the processor, a programming task to be executed and translate industry-specific terms in the programming task to non-specific terms applicable across industries. The instructions are also executable by the processor to cause the processor to receive a user profile for a developer to execute the programming task, wherein the user profile indicates a level of expertise of the developer and identify a target level of abstraction for the supporting material based on the level of expertise of the developer. The program instructions are also executable by the processor, to cause the processor to extract supporting documentation associated with the completed task that is similar to the programming task to be executed and display supporting material associated with the completed task to a computing device to execute the programming task via a navigable graph, wherein the navigable graph is presented at a hierarchical level to match the target level of abstraction.
The present invention may be a system, a method, and/or a computer program product at any possible technical detail level of integration. The computer program product may include a computer readable storage medium (or media) having computer readable program instructions thereon for causing a processor to carry out aspects of the present invention.
The computer readable storage medium can be a tangible device that can retain and store instructions for use by an instruction execution device. The computer readable storage medium may be, for example, but is not limited to, an electronic storage device, a magnetic storage device, an optical storage device, an electromagnetic storage device, a semiconductor storage device, or any suitable combination of the foregoing. A non-exhaustive list of more specific examples of the computer readable storage medium includes the following: a portable computer diskette, a hard disk, a random access memory (RAM), a read-only memory (ROM), an erasable programmable read-only memory (EPROM or Flash memory), a static random access memory (SRAM), a portable compact disc read-only memory (CD-ROM), a digital versatile disk (DVD), a memory stick, a floppy disk, a mechanically encoded device such as punch-cards or raised structures in a groove having instructions recorded thereon, and any suitable combination of the foregoing. A computer readable storage medium, as used herein, is not to be construed as being transitory signals per se, such as radio waves or other freely propagating electromagnetic waves, electromagnetic waves propagating through a waveguide or other transmission media (e.g., light pulses passing through a fiber-optic cable), or electrical signals transmitted through a wire.
Computer readable program instructions described herein can be downloaded to respective computing/processing devices from a computer readable storage medium or to an external computer or external storage device via a network, for example, the Internet, a local area network, a wide area network and/or a wireless network. The network may comprise copper transmission cables, optical transmission fibers, wireless transmission, routers, firewalls, switches, gateway computers and/or edge servers. A network adapter card or network interface in each computing/processing device receives computer readable program instructions from the network and forwards the computer readable program instructions for storage in a computer readable storage medium within the respective computing/processing device.
Computer readable program instructions for carrying out operations of the present invention may be assembler instructions, instruction-set-architecture (ISA) instructions, machine instructions, machine dependent instructions, microcode, firmware instructions, state-setting data, configuration data for integrated circuitry, or either source code or object code written in any combination of one or more programming languages, including an object oriented programming language such as Smalltalk, C++, or the like, and procedural programming languages, such as the “C” programming language or similar programming languages. The computer readable program instructions may execute entirely on the user's computer, partly on the user's computer, as a stand-alone software package, partly on the user's computer and partly on a remote computer or entirely on the remote computer or server. In the latter scenario, the remote computer may be connected to the user's computer through any type of network, including a local area network (LAN) or a wide area network (WAN), or the connection may be made to an external computer (for example, through the Internet using an Internet Service Provider). In some embodiments, electronic circuitry including, for example, programmable logic circuitry, field-programmable gate arrays (FPGA), or programmable logic arrays (PLA) may execute the computer readable program instructions by utilizing state information of the computer readable program instructions to personalize the electronic circuitry, in order to perform aspects of the present invention.
Aspects of the present invention are described herein with reference to flowchart illustrations and/or block diagrams of methods, apparatus (systems), and computer program products according to embodiments of the invention. It will be understood that each block of the flowchart illustrations and/or block diagrams, and combinations of blocks in the flowchart illustrations and/or block diagrams, can be implemented by computer readable program instructions.
These computer readable program instructions may be provided to a processor of a computer, or other programmable data processing apparatus to produce a machine, such that the instructions, which execute via the processor of the computer or other programmable data processing apparatus, create means for implementing the functions/acts specified in the flowchart and/or block diagram block or blocks. These computer readable program instructions may also be stored in a computer readable storage medium that can direct a computer, a programmable data processing apparatus, and/or other devices to function in a particular manner, such that the computer readable storage medium having instructions stored therein comprises an article of manufacture including instructions which implement aspects of the function/act specified in the flowchart and/or block diagram block or blocks.
The computer readable program instructions may also be loaded onto a computer, other programmable data processing apparatus, or other device to cause a series of operational steps to be performed on the computer, other programmable apparatus or other device to produce a computer implemented process, such that the instructions which execute on the computer, other programmable apparatus, or other device implement the functions/acts specified in the flowchart and/or block diagram block or blocks.
The flowchart and block diagrams in the Figures illustrate the architecture, functionality, and operation of possible implementations of systems, methods, and computer program products according to various embodiments of the present invention. In this regard, each block in the flowchart or block diagrams may represent a module, segment, or portion of instructions, which comprises one or more executable instructions for implementing the specified logical function(s). In some alternative implementations, the functions noted in the blocks may occur out of the order noted in the Figures. For example, two blocks shown in succession may, in fact, be accomplished as one step, executed concurrently, substantially concurrently, in a partially or wholly temporally overlapping manner, or the blocks may sometimes be executed in the reverse order, depending upon the functionality involved. It will also be noted that each block of the block diagrams and/or flowchart illustration, and combinations of blocks in the block diagrams and/or flowchart illustration, can be implemented by special purpose hardware-based systems that perform the specified functions or acts or carry out combinations of special purpose hardware and computer instructions.
The role of computing devices in modern society is increasing year over year. In fact, it is not uncommon for a user to interact with multiple computing devices a day, either locally or remotely via a network. Among a variety of tasks, developers 1) ensure that program code of computing devices execute as intended and 2) develop new program code to carry out new functionalities. In general, a developer should have some degree of familiarity with a particular subject while performing a programming task related to that subject. However, the knowledge dictated by a programming task in a specific industry may not be readily available and pre-established material with no specific focus may not help the developer to effectively acquire the correct knowledge to adequately carry out the programming task. That is, unless a developer is familiar with a particular industry, the developer may have to absorb diverse, complex, and large resources to perform industry-aware programming tasks.
As a specific example, a developer may be assigned to write source code or change a configuration file within an oil and gas paradigm. A work order may be generated which describes the programming task to be executed. As there is industry-specific context both in terms used and programming code generated, there may be industry-specific practices used to carry out the programming tasks within that industry. However, a developer may be new to the industry, or may be experienced in another industry. As such, in order to execute a programming task in the new industry, the developer may review and analyze tens or hundreds of deliverables, supporting documentation, etc., before he/she can begin work on the programing task in the new industry. As a specific example, a developer may have multi-year experience in the oil and gas industry and be familiar with the nomenclatures, processes, and ontology of that industry, but may be moved to another industry such as finance. It may be that the nomenclatures, protocols, and ontology between the oil and gas and finance industries may share some similarities, however, there may be differences and coming up to speed on the finance industry may be labor-intensive and may result in program code that is inefficient and may not function as intended.
Accordingly, the system of the present specification may receive certain input, such as the programming task to be executed and a profile of the developer which indicates their field of expertise. Based on this input, the system may generate supporting material that draws upon the experience of the developer in their previous field of expertise to reduce the quantity of materials consumed in generating code in the new field. That is, the system may generate supporting materials for a finance programming task knowing that the developer is a senior level developer coming from the oil and gas industry. Accordingly, the present systems and methods build customized supporting materials to execute industry-aware program code tasks.
Put another way, programming tasks depend upon industry domain knowledge, such that a developer should be familiar with the subject matter and programming protocols, processes, and ontology of the industry in which he/she works. However, to become familiar, a developer may spend several hours reading through different materials, which apart from being diverse, may be very long. The challenge is that the developer may not know which aspects of such documents he/she should pay more attention while executing a programming task. Moreover, as there may be industry-specific ontologies and practices, if such practices are not complied with, the work product may not perform as intended. That is, the output of the programming task may be ineffective, inefficient, and may not achieve the desired outcomes.
Accordingly, the present system relies on the use of semantic analysis of deliverables (e.g., code, config files) to calculate the similarity level of a programming task to be completed with tasks already completed. A cross-industry ontology handler may match the completed tasks with the task to be performed notwithstanding a difference in terminology, nomenclature, constructs, or practices with another industry. In an example, a machine-learning system builds a hierarchical cluster that is used as navigable graph by the developer to navigate the supporting material that is generated.
As such, the present system streamlines the generation of supporting material such that a more efficient code output is generated. A particular example is now provided. In this example, an organization may have completed programming tasks for the oil and gas industry as well as for the solar industry. Both may include programming tasks for asset management and work management, but each may have some particular standards to comply with such that some programming task constructs are different. As a particular example, an oil and gas program code may have a test to implement a change status rule for an asset work order from awaiting approval to approved. Before marking a work order approved, there may be some validations codes which correspond to items checked against the asset and work order before allowing a user to do a status change. The items to be checked may be specific to the oil and gas industry.
In the solar industry there may be a similar status change for an asset work order from awaiting approval to approved. However, the items to be checked against the asset may be different and there may be other differences. Accordingly, the present specification provides industry specific content for the programming task in the solar industry while building off any previous experience a developer may have in the oil and gas industry.
Such a system, method, and computer program product may 1) generate and provide supporting material that is specific to a particular programming task; 2) is specific to the background of the user, rather than being generic, 3) results in quicker programming task completion; and 4) provides more intelligent solutions as extraneous and irrelevant supporting material is excluded from being generated.
As used in the present specification and in the appended claims, the term “supporting documentation” refers to the raw content associated with a completed task prior to inference of an abstraction level classifier or text classifier. Supporting documentation may include such things as system help documents, examples of source codes, and examples of configuration files among others.
As used in the present specification and in the appended claims, the term “supporting material” refers to the supporting documentation as altered by an abstraction level classifier or text classifier. The supporting material includes the data after the system infers an abstraction level classifier or text classifier by employing machine learning techniques such as support vector machine (SVM), Naïve Bayes, and others.
As used in the present specification and in the appended claims, the term “a number of” or similar language is meant to be understood broadly as any positive number including 1 to infinity.
In some examples, this may include drawing supporting documents from other industries. For example, within different industries there may be different “commits,” wherein a commit (104) refers to some aspect of the program code that has been implemented and rolled out. Commits (104) may be referred to as versions of a particular program code. Moreover, within different industries there may be specific ontologies (106), wherein an “ontology” refers to domain specific vocabulary, variables, etc. used in a particular industry. As described above, there may be some similarities between different industries, for example oil and gas may have work order approval program code. However, the specific components of the program code may be different per industry. That is, each industry may have its own commits (104-1, 104-2, 104-3) and ontologies (106-1, 106-2, 106-3). Rather than scouring un-indexed documentation, the system (100) provides intelligently filtered information to generate industry-specific supporting material. These commits (104) and ontologies (106) may be stored in a database of the system (100), or in a database that is accessible by the system (100). The system (100) may also rely on other sources (106) of documents. In addition to the commits (104) and ontologies (106), the system (100) may rely on other sources (106) such as user guides, system help documents, redbooks, tickets, and user feedback, among others.
Based on a similarity between the programming task to be executed and any of the afore-mentioned commits (104), the system may identify completed tasks, i.e., commits, and other supporting documents that are similar to the programming task to be completed. The system (100) may then extract these supporting documents and customize them for the developer based on, for example, a level of expertise of the developer. The supporting material, i.e., the supporting document with annotations and other manipulations is then provided to the computing device (102).
The memory may include a computer-readable storage medium, which computer-readable storage medium may contain, or store computer usable program code for use by or in connection with an instruction execution system, apparatus, or device. The memory may take many types of memory including volatile and non-volatile memory. For example, the memory may include Random Access Memory (RAM), Read Only Memory (ROM), optical memory disks, and magnetic disks, among others. The executable code may, when executed by the processor cause the processor to implement at least the functionality of providing cross-industry supporting materials.
As described above, each industry may have different vocabulary/ontology. For example, in the medical industry a supervisory authority may be a doctor whereas in the oil and gas industry the supervisory authority may be a superintendent or an operations manager. As such, there are different specific practices, nomenclatures, and constructs that are applicable to the program tasks in the different industries.
However, there may be similarities between these industries notwithstanding the different ontologies. For example, a persona may refer to an individual with particular responsibilities. While each industry may have such a persona, each industry may characterize this persona differently. Accordingly, the present system maps the ontologies such that similarities may be determined across industries. Continuing the example from above, a doctor in the medical industry may be mapped to an operations manager in the oil and gas industry such that any programming task involving a doctor may be provided as supporting material for a programming task that involves an operations manager in the oil and gas industry. The system (100) as described herein identifies task similarities and cross-ontology similarities such that supporting materials for a programming task in one industry can be relied on in the execution of a programming task in a different industry, notwithstanding any industry-specific distinctions across the programming tasks.
The system (100) may include a database (106) which includes completed programming tasks and associated supporting documentation per completed programing task. That is, each programming task that is completed may be saved to the database (106), regardless of the industry to which the programming task pertains. It is this database (106) of completed tasks and associated supporting documents that may be relied on in providing supporting materials for second industry task execution.
The database may include any variety of additional supporting documentation including user guides, system help, redbooks, tickets, user comments, plan/track system information, code repositories, etc. While particular reference is made to specific supporting documents in the database (106), the database (106) may include any and different types of supporting documents.
The system (100) may include a cross-ontology handler (208) which identifies, from completed tasks in the database (106), terms that are different but similar to terms in the programming task to be executed. That is, the cross-ontology handler (208) discovers via ontologies, the similarity of activities that are from different industries. The cross-ontology handler (208) may include a processor and memory and is responsible for understanding more than one ontology and mapping entities across multiple ontologies. For instance, “change status” may be an ontology entity that represents an “action.” This entity may be found in different ontologies such as a health ontology and an oil and gas ontology. However, those mapped entities perform different validation rules for each ontology. Accordingly, the cross-ontology handler (208) may be able to identify similar activities across different industry domains by mapping the specific industry terms across different industry domains.
The system (100) also includes a task similarity handler (210) which identifies, from the database (106), a completed task that is similar to a programming task to be executed. That is, as described above, different industries may have similar tasks to be executed, notwithstanding differences in the verbiage and variables used. Accordingly, the task similarity analyzer (210) analyzes how similar a programming task to be completed is in relation to previously completed programming tasks. In some examples, the similarity is based on a natural language comparison of the programming task to be executed comprising a variety of techniques, such as, cosine similarity, jaccard distance, normalized compressed distance (NCD), word embeddings, and others. The task similarity analyzer (210) may rely on a mapping generated by the cross-ontology handler (208) in the natural language processing. That is, the cross-ontology handler (208) may generate a mapping between different entities across ontologies and this mapping may be used by a natural language processor to determine whether two tasks are similar.
In an example, the task similarity analyzer (210) may convert the completed task and/or supporting documentation into a vector representation. In such a vector representation, the system (100) may be able to determine whether or not the completed task and/or supporting documentation is in fact similar to the programming task to be completed. That is the programming task that is to be executed may also be converted into a vector representation, and this vector representation may be used to ensure similarity.
In some examples the task similarity analyzer may rely on operations performed by the semantic analyzer (214) to determine similarity. That is, the semantic analyzer (214) may semantically analyze a deliverable output from the programming task and may also semantically analyze the completed task and supporting documentation to aid in similarity determination.
For example, the semantic analyzer (214) may classify the supporting documentation to assign each supporting document a level of abstraction. That is, the supporting documents may be classified based on the level of detail they include. The semantic analyzer (214) which may include a natural language processor or other textual analysis device may analyze the supporting document or metadata associated with the supporting document to ascertain which level of detail is found in the respective supporting document. The level of abstraction may be a numeric value. For example, a numeric value of 0 may indicate the document includes production documentation, while a numeric value of 1 may indicate the document includes a bpm diagram. Similarly, a numeric value of 2 may indicate the document includes a ticket, while a numeric value of 3 indicates a code sample is included in the supporting document.
As another example, the numeric value indicating the level of abstraction may be on a scale from 1 to 5 where 1 includes few details as compared to level 5 which may contain more details to be shown to the developer. The level of abstraction classifier is used, along with the user's profile to determine what level of detail to provide to the user. For example, an experienced user in the industry may have sufficient experience that data with a level of 1 would be sufficient where as an intern or someone new to the industry may desire more detail, as such supporting documents with a level of 5 may be presented.
Thus, in summary, the semantic analyzer (214) infers a text classifier that correlates the vector representation of the supporting documents with the abstraction levels. The abstraction level classifier can be inferred using techniques such as, deep learning neural networks, support vector machines, and naive bayes. As a consequence, the system (100) stores the inferred model as a supporting material model in the database (218).
The system (100) also includes a document extractor (212). After finding suitable supporting documents, i.e., those documents that have a threshold similarity with the programming task to be completed based on some similarity comparison such as natural language processing, are found, the document extractor (212) collects, or extracts, the supporting documentation associated with the completed task that is determined to be similar to the programing task to be analyzed. That is, the document extractor (212) may collect the code snippets, examples of configuration files, commits, etc. from a completed task that is deemed similar to the programming task to be completed. The document extractor (212) may collect other supporting documents as well such as user guides, manuals, etc. that relate to the completed task.
The system (100) also includes the semantic analyzer (214) introduced above. As described there, the semantic analyzer (214) semantically analyzes the supporting documentation. Semantic analysis may include any number of techniques, such as, corpus-based similarity operations and knowledge-based similarity operations.
The system (100) also includes a supporting material generator (216) to generate the supporting material associated with the completed task for a computing device (
The supporting material generator (216) may generate the supporting material based on a mapping between the level of abstraction, hierarchical level of a navigable tree graph, a user profile for a developer, wherein the user profile indicates a level of expertise of the developer, and the programming task to be executed. As demonstrated above, the amount of detail with which the supporting material is presented may be based on the level of expertise of the user relative to the programming task to be completed. For example, a senior developer in the finance industry may not demand supporting materials in as much detail as an intern developer. Accordingly, based on the user profile indicating a developer is experienced in an industry related to the programming task to be completed, the supporting material generator (216) may determine that a certain level of abstraction applies, i.e., a level 1 with less detail. This level of abstraction may govern which level of a hierarchical graph of the supporting material is to be presented to the user. For example, the supporting documentation may be presented as a tree graph, where higher levels on the tree graph represent more generic, and less detailed information. Given a senior developer's level of expertise, higher levels may be sufficient as the senior developer already has experience, and thus does not demand the more detailed information. Accordingly, the supporting material generator (216) may include as input the user profile for the developer and the programming task and may output the supporting material at a hierarchical level that maps to the level of abstraction associated with data in the user profile. As such, the system (100) provides supporting documentation for a programming task to be executed. The supporting documentation may come from any industry, not just the industry of the current programming task.
The system (
The system (
In this example, the database (218) may identify a completed task that is similarly a change status of a work order application from “waiting approval” to “approved” for a task completed within the oil and gas industry which the developer may be familiar with given their history in the oil and gas industry. In this example, given the similarity in the tasks, there may be overlapping supporting materials (422) which may include code samples of changing the status to “approve” for other records and commit text and comments along with the code explaining work order change status implementation. The provided supporting materials (322) may also include a description of an ISO standard for the solar energy which identifies a process to approve a work order.
As described above, the provision of supporting material may be based on the level of expertise of the user as determined by the user profile (420). For example, a user profile (420) may indicate a title for the user, or may have a database of projects worked on by the user which may indicate the user's expertise in a particular area. Accordingly, the system (
The method (500) may include collecting (block 502) supporting documents. The system (
In an example, the supporting documents may be stored (block 503) in a supporting document repository portion of a database (
In an example, the method (500) includes converting (block 504) the industry specific terms to non-specific terms. Specifically, the cross-industry ontology handler (
The system (
The system (
The system (
The method (600) may include processing (block 602) a user profile to determine the level of abstraction. As described above, the level of expertise of a user may dictate how much detail to provide to the user as supporting material for execution of the programming task. For example, a senior developer may be provided with less supporting material given their experience in programming. Accordingly, the system (
The method (600) includes converting (block 603) the programming task to non-specific terms. That is, similar to the supporting documents, the cross-ontology handler (
The method (600) includes semantically analyzing (block 604) the programming task. That is, the semantic analyzer (
The method (600) may include retrieving (block 605) an associated supporting material model. That is, the system (
The method (600) may include retrieving (block 606) the navigable cluster. As described above, the supporting materials may be generated as a hierarchy where the supporting materials become increasingly detailed lower on the tree graph. That is, the system (
The method (600) may include collecting (block 607) data of the programming task. That is, the system (
According to the method (600), non-specific terms are replaced (block 608) with industry specific terms. That is, the cross-ontology handler (
The method (600) may include refining (block 609) supporting materials using replaced terms. That is, the system (
According to the method (700), the cross-ontology handler (
The method (700) may include, following completion of the programming task to be executed, updating (block 702) the user profile. Specifically, the system (
The method (700) may include updating (block 703) the classifiers. That is, the system (
The method (700) may include updating (block 704) the supporting material repository. That is, following completion of the programming task, the current programming task may be added to the repository of completed tasks, to be compared against subsequently assigned programming tasks. Updating (block 704) the supporting material repository may also be based on user feedback. That is, the user may have had a specific experience with the presented supporting material and the system (
The method (700) may include updating (block 705) navigable graphs based on the user feedback and more specifically collecting feedback regarding the hierarchical level at which the navigable graph is presented. That is, the system (
The method (700) may include updating (block 707) the classifier/abstraction level mapping. As described above, this mapping provides the system with information as to how much detail to provide to a given developer. Accordingly, the system (
Referring to
In summary, the present specification describes a method that includes an action where, in response to initiating a system according to predetermined types of supporting material documents using a parameter indicating document sources associated to respective levels of detail according to their content, retrieving textual documentation available over a network from predetermined repositories using predefined configurations associated with the predetermined types of supporting material documents.
In an example, the method includes retrieving additional items including tickets, user stories, and other items from planning/tracking systems using the predefined configurations associated with the predetermined types of supporting material documents. In an example, the method includes retrieving source code from repositories together with associated comments using the predefined configurations associated with the predetermined types of supporting material documents. The method includes storing artifacts retrieved in a supporting material repository including parsing content to keep just textual data.
Industry-specific terms are translated to corresponding generic synonyms using a cross-industry ontology. The textual data is converted into a vector representation using methods including natural language processing techniques to remove stop-words, a bag-of-words technique to transform the textual data and normalization to reduce an undesired bias of unbalanced data. An abstraction level of the documents is predicted using an inferred text classifier with labelled documents stored as artifacts to correlate the vector representation of the supporting materials with abstraction levels of the predetermined types of supporting material documents. The inferred model may be stored in a supporting material models repository.
In an example, a dependency and navigable graph is generated using hierarchical clustering with the vector representation of the supporting materials to create a tree-based hierarchy, linking and combining similar clusters according to predetermined linkage criteria, as a representation of an amount of detailed information in which higher-level nodes groups larger numbers of supporting materials and lower-level nodes contain a few targeted documents. The dependency and navigable graph may be stored in a supporting material clusters repository.
Using user feedback, a most appropriate node of the dependency and navigable graph is determined in response to collecting the user feedback about a level of abstraction of the documents and amount of supporting material while retrieving the similar clusters.
A dataset may be assembled that correlates a programming task and a user profile with the level of abstraction of the documents and the amount of supporting material. A text classifier may be inferred using the dataset to predict a level of abstraction and an amount of supporting material by converting the textual data into a vector representation using methods including natural language processing techniques to remove stop-words, a bag-of-words technique to transform the textual data of the user profile and the programming tasks and normalization to reduce an undesired bias of unbalanced data.
In an example, responsive to receiving a programming task by a user, the system detects a user profile according to capabilities and history of feedback of the user.
The programming task may be translated to the industry specific terms using the cross-industry ontology. The programming task is converted into a vector representation using methods including natural language processing techniques to remove stop-words, a bag-of-words technique to transform the textual data of the programming task and normalization to reduce an undesired bias of unbalanced data. The level of abstraction and amount of supporting material is predicted using the user profile and the programming task with the text classifier model.
Customized supporting material clusters are presented according to the level of abstraction and amount of supporting material predicted in the form of the dependency and navigable graph focusing on a cluster predict in which the supporting materials are shown in a spatial representation according to their similarities.
In response to a user attempting to deliver the programming task, the programming task is enhanced by collecting terms in changed system files, including variable names, code comments, system properties, and diagrams, using a semantic analysis technique to retrieve meaningful terms to later enhance the programming task by concatenating terms processed in converting the programming task text into a vector representation with the terms collected.
In an example, system file terms are translated to the industry specific terms using the cross-industry ontology retrieved.
Customized supporting material may be refined using the system files terms translated by retrieving more specific supporting materials of nearest clusters from the dependency and navigable graph according to the system file terms translated. Customized supporting material refined by the developer is presented. The cross-industry ontology handler may be enhanced with terms that at least one of complement existent terms given a relative vicinity in a text and reinforces weight of the existent terms.
The user profile repository may be updated with code delivered by the user. In an example, the abstraction level and clusters containing the additional supporting material provided by the user are predicted using the text classifier model and considering the terms collected during the programming task.
In an example, the abstraction level and cluster are presented to the user and the supporting material repository is updated using collected implicit and explicit feedback while the user consumes the customized supporting material.
Aspects of the present system and method are described herein with reference to flowchart illustrations and/or block diagrams of methods, apparatus (systems) and computer program products according to examples of the principles described herein. Each block of the flowchart illustrations and block diagrams, and combinations of blocks in the flowchart illustrations and block diagrams, may be implemented by computer usable program code. In one example, the computer usable program code may be embodied within a computer readable storage medium; the computer readable storage medium being part of the computer program product. In one example, the computer readable storage medium is a non-transitory computer readable medium.
The descriptions of the various embodiments of the present invention have been presented for purposes of illustration, but are not intended to be exhaustive or limited to the embodiments disclosed. Many modifications and variations will be apparent to those of ordinary skill in the art without departing from the scope and spirit of the described embodiments. The terminology used herein was chosen to best explain the principles of the embodiments, the practical application or technical improvement over technologies found in the marketplace, or to enable others of ordinary skill in the art to understand the embodiments disclosed herein.
