Abstract: Systems and methods for code repository embedding using attention mechanism for tagging and summarization are disclosed. According to one embodiment, a method for code repository embedding may include: (1) extracting, by a computer program executed by an electronic device, docstring embeddings, code embeddings, and dependency embeddings from scripts in a repository (2) applying, by the computer program, a machine learning algorithm to each of the docstring embeddings, code embeddings, and dependency embeddings; (3) concatenating, by the computer program, outputs of the machine learning algorithm; (4) weighting, by the computer program, the concatenated outputs of the machine learning algorithm using an attention mechanism, resulting in a repository representation comprising an abstract vector; and (5) tagging or summarizing, by the computer program, the script using its repository representation.

Abstract: Example methods, apparatuses, and/or articles of manufacture are disclosed that may be implemented, in whole or in part, using one or more computing devices to: compare first nodes of a first call graph to second nodes of a second call graph based, at least in part, on hash values associated with the first and second nodes to identify one or more of the second nodes that are absent from the first nodes.

Abstract: An approach to identifying the use of deprecated source code in software repositories and recommending a replacement. Parsing one or more software repositories for software source code, identified as deprecated, by a machine learning model. Responsive to identifying the deprecated software source code, alerting a first one or more software developers responsible for maintaining a software source code module using the deprecated software source code; and recommending an alternative software source code for use in the software source code module to replace the deprecated software source code to the first one or more software developers.

Abstract: A quality assurance system includes a mainframe deployment device in communication with a mainframe device with a codebase. The mainframe deployment device initializes a branch repository corresponding to a code region of the codebase, identifies, for a code element of the code region, a timestamp indicating a creation time and a user identifier indicating an owner, populates the branch repository with the code element based on the code region and the timestamp, applies a code security scan to the branch repository to identify and resolve a code security issue, and applies a code quality scan to the branch repository to identify a code quality issue in the code element, assign the code element to the user identifier based at least partially on the timestamp, and route the code element along with information regarding the code quality issue to correct the code quality issue in the code element.

Abstract: Methods and systems for improved and efficient template reconciliation are disclosed. By comparing the original template with the proposed modified template, the template management system can determine the minimally necessary modifications in a relational database to implement all changes and automatically generate scripts to update the template in a short amount of time. The present subject can improve computer and network efficiency by eliminating constant and in-between modifications of the template. It also saves computing resources by avoiding the complete deletion and replacement of a template in the relational database.

Abstract: Systems and methods for auto-captioning repositories from source code are disclosed.

Abstract: A data processing system implements obtaining, at a file services platform, first mapping information by mapping files, folders, or a combination thereof stored on each of a plurality of client devices associated with a first user. The data processing system further implements synchronizing the first mapping information with the plurality of client devices, receiving a first request for a first file from a first client device of the plurality of client devices, where the first file stored locally on a second client device of the plurality of client devices. The data processing system further implements requesting that the second client device upload an instance of the first file to the file services platform; receiving the instance of the first file from the second client device; and causing the first client device to download the instance of the first file from the file services platform to the first client device.

Abstract: A method for managing information handling resource versions includes maintaining one or more snapshots of one or more validated release versions for a group of components. Each validated release version indicates a component version for each component in the group. Each component version in a higher validated release version is required to be greater than or equal to a corresponding component version in a lower validated release version. Responsive to identifying an instance of the component group in an non-validated state, disclosed methods identify a lowest validated release version that “covers” the non-validated state, wherein a validated release version covers any state in which no component version is greater than its corresponding component version in the validated release version. The instance of the component group is updated to a validated release version that equals or exceeds the lowest validated version.

Abstract: Deployments of microservices executing in a cloud are automatically managed. Some microservices are deployed on dedicated nodes, others in serverless configurations. Rates of invocation and runtime data of microservices are monitored. Responsive to the monitored rate of invocation of a microservice running serverless exceeding a given threshold, the microservice is automatically redeployed to a dedicated node. A microservice executing on a dedicated node may be redeployed serverless if the infrequency with which it is called is sufficient. Microservices can be automatically redeployed between different dedicated nodes with different capacities based on monitored usage. The underlying cloud service provider may be automatically monitored for changes in serverless support functionality. Responsive to these changes, the thresholds at which microservices are redeployed can be automatically adjusted.

Abstract: A method comprises executing a code in a development environment for: documenting versions of source files of a software program in a plurality of source documentation objects, where at least one of the source documentation objects comprises a textual description comprising one or more text-extracts, each text-extract comprising at least one marked token extracted from one of the versions of the source files; accessing a new version of a source file; performing an identification of when at least one updated token in the new version is different from the marked token; and in response to the identification: classifying the updated token according to differences identified between the updated token and the marked token; and subject to the classification being a member of a set of updatable changes, generating an updated source documentation object by modifying the text-extract in the textual description according to the classification and the differences.

Abstract: A version control system implemented in software and executed by one or more processors that provides for change set integration for diverse types of objects. The system may be configured to handle a wide range of objects of different types committed to the version system by storing and/or versioning the objects, change sets, and complex relationships between objects and object dependencies. Unified support for development operations may be provided as assets under version control may optionally be deployed, rolled back, compared to a corresponding live environment, and tested thus providing for sophisticated development and operational cycles. The system provides automatic and/or semi-automatic object integration such as may be useful for continuous development and integration and feature based development.

Abstract: In some examples, one or more processors configured by executable instructions receive, from a first computing device, at least one key-to-string mapping related to updated software located at a repository. The one or more processors further receive an indication of a target locale associated with the updated software. The one or more processors may compare a first string from the at least one key-to-string mapping with translated strings maintained in a database in association with the target locale to determine that a translated version of the first string for the target locale is present in the database. The one or more processors may send the translated version of the first string from the database to the first computing device in association with the updated software located at the repository.

Abstract: Methods, systems, and apparatus, including computer programs encoded on computer storage media, for generating recipes having platform-independent, resource-agnostic commands for performing work in a cloud computing platform. One of the systems includes a plurality of executors, each executor being operable to receive a recipe comprising one or more platform independent, resource agnostic commands, each command corresponding to a requested service to be performed by an execution engine on an underlying computing platform, translate each platform independent, resource agnostic command of the recipe into one or more platform independent, resource specific requests that satisfy the requested service on the underlying computing platform and make each of the one or more platform independent, resource specific requests to one of the one or more execution engines using a platform independent execution engine application programming interface (API).

Abstract: Systems and methods that provide centralized communication across feature programming workflows using software development lifecycle tools that dynamically determine temporal alerts are disclosed herein. By dynamically determining events that are temporally relevant, the system accounts for changes in an application timeline that comprises a plurality of events, in which each event of the plurality of events indicates when a respective feature of the plurality of features is available for use by the application, and in which the location of each event constantly changes.

Abstract: Each of a plurality of events associated with a workspace or stream are stored to a functional data structure. Each of the plurality of events includes at least an indication of when an operation in the workspace or stream occurred and who performed the operation. Nodes of a change set history tree corresponding to the events can be recursively identified until a node corresponding to a change set of interest is identified. Responsive to identifying the node corresponding to the change set of interest, the event corresponding to such node can be identified as an event that added the change set of interest to the workspace or stream. The indication of when the operation represented by the event occurred and who performed the operation can be retrieved from the subject event. The indication of when the operation represented by the event occurred, and who performed the operation, can be output.

Abstract: Embodiments of the present disclosure relate to systems and methods for creating logical groups of packages by tagging individual packages with a tag associated with metadata corresponding to packages that are part of the group. A group of packages may be defined from a plurality of packages that make up an application ecosystem using the tag. A command to perform a first operation of a set of operations performed by the package manager on the group of packages may be provided to a package manager, wherein the command may reference the tag and wherein the package manager is modified to perform each of the set of operations on one or more of the plurality of packages simultaneously. The first operation may be performed by the package manager on the group of packages simultaneously using the metadata to identify each package that is part of the group.

Abstract: Implementations set forth herein relate to an automated assistant that allows third party applications to inject dependencies to leverage automated assistant functions. Furthermore, enabling such dependency injections can allow third party applications to preserve privacy of any application content that is used during execution of automated assistant functions. In some implementations, a third party application can initialize a function with an assistant dependency using parameters that are tagged as private. Initializing a function in such as a way can allow private content communicated between the third party application and the automated assistant to be abstracted for security purposes. The abstracted content can thereafter be communicated to a remote server—such as a server hosting an extensively trained machine learning model. Intelligent output provided by the server can then be incorporated into one or more processes of the third party application without comprising security.

Abstract: Disclosed herein are various embodiments a code simplification system. An embodiment operates by receiving an identification of both a first code object and a second code object directed to producing a similar result. It is determined that the first code object and the second code object each include code subsets that correspond to each other. Differences between the code subsets of the first code object and the second code object are identified. The differences may include at least one of: a different ordering of the plurality of code subsets between the first code object and the second code object, or an additional code subset in the first code object that is not included in the second code object. A notification is provided with the differences, and input is received indicating an action to take by which either the first code object or the second code object are updated.

Abstract: A method for providing mainframe codebase maintenance and security is performed by a mainframe deployment device. The method includes importing the mainframe codebase from a mainframe device. The mainframe codebase includes at least one code region including at least one code element. The method also includes identifying the code regions and initializing a branch repository corresponding to at least one identified code region. The method includes querying the imported mainframe codebase to identify, for the code elements, a user identifier and a source region. The method includes populating the branch repositories with the code elements based on the respective source region. The method includes applying a code quality scan to the populated branch repositories to identify a code quality issue in the respective code elements. The method also includes submitting at least one code element having an identified code quality issue to a user device correct the code quality issues.

Abstract: An electronic device includes a processor and a storage device having a file system with a plurality of directories. The processor executes an application that has a dependency on a shared library, the shared library having a dependency on a runtime component. When executing the application, the processor loads the shared library, the loading including executing a constructor for the shared library. Executing the constructor causes the processor to identify a selected directory where a compatible version of the runtime component is to be found based on a location of the shared library in the file system, the location of the shared library being determined from an application context from the application. When subsequently loading the runtime component for execution, the processor locates the runtime component in the selected directory.

Abstract: This disclosure provides methods and techniques of data replication involving cross replication group (RG) references. The present disclosure avoids automatic replication failing when an entity in an RG refers to another entity external to the RG. The entity to be replicated within the RG is referred to as the “referring entity,” and the entity as the dangling reference is referred to as the “referred entity.” Although the referring and referred entities are not replicated together in a replication operation, the referred entity may have already been replicated to the target account in another replication operation on a different replication group. In such cases, the data replication procedure may, according to aspects of the present disclosure, check if the referred entity has already been replicated, and if so, proceed to replicate the referring entity without fail, and link the referring and referred entities to enable normal functioning of the referring entity.

Abstract: According to an aspect, there is provided a computing device for performing the following. The computing device maintains, in a database, a first deviation detection algorithm for evaluating values of a first deviation metric. The computing device obtains, in the code editor, a plurality of logical lines of code and performs, for at least one logical line of code, the following. The computing device evaluates, using the first deviation detection algorithm, for a program instruction defined in a logical line of code, a value of the first deviation metric based at least on one or more other program instructions. The computing device selects a first color based on the first deviation metric from a first colormap. Finally, the computing device colors, in part or fully, a background or a text of the logical line of code or a graphical element associated with it with the first color.

Abstract: Provided are systems and methods that can extract part data from a PLM database and suggest changes to the manufacturing of the part. In one example, the method may include querying a database for a plurality of values of a part to be manufactured from a plurality of fields of computer-aided design (CAD) file stored in the database, mapping the plurality of fields of the CAD file to a plurality of corresponding fields of a host platform based on a type of the database, extracting the plurality of values from the CAD file and transferring the plurality of values to the mapped plurality of corresponding fields of the host platform, determining changes to one or more manufacturing attributes of the part to be manufactured based on the transferred plurality of values, and outputting the changes to a display.

Abstract: A computer implemented method for testing rules by a computing device including selecting a current version of a rule and prior version of the rule, comparing the prior version of the rule and the current version of the rule to each other to identify a type of change made in the current version of the rule with respect to the prior version of the rule, and testing the prior version of a rule and the current version of the rule using a common data set, the testing being based on the identified type of change. The test result is provided to a user.

Abstract: Disclosed are various approaches performing actions on data items in a third-party service with a network-accessible application programming interface from an email client. The email client can perform an action as specified by an email service profile, which specifies how to identify the email message, the data item and how to interact with the network-accessible application programming interface.

Abstract: Disclosed is a method, a device, a system and/or a manufacture of computing hardware and software design testing auditability, including for critical control systems, functional safety, and autonomous vehicle component certification. In one embodiment, a system includes a test recording routine that defines a database relation associating a design version within a design dependency graph and a test version. The system includes a design audit interface that generates a first validation request to validate an isolation testing. An isolation validation engine determines that the design version has completed the isolation testing where each design script of the design fileset was executed in a discrete environment. In addition, a reproduction validation engine may also retrieve the design fileset and the runtime environment data, reassemble a workspace data, execute the test script, and compare the result data to a previous result data to validate reproducibility of the testing.

Abstract: Disclosed herein is a computing system that includes a memory and a processor coupled to the memory. The memory storing processor executable instructions for an interface engine that integrates robotic processes into a graphic user interface of the computing system. The processor executes the interface engine to cause the computing system to receive inputs via a menu of the graphic user interface and to automatically determine the robotic processes for display in response to the inputs. The interface engine further generates a list including selectable links corresponding to the robotic processes and displays the list in association with the menu.

Abstract: Provided is a process including: writing classes using object-oriented modelling of modeling topics; scanning the classes to determine class definition information; receiving from a subscribing modeling object a request for a subscription to a given modeling topic in a given modeling topic class, the subscription request including a modeling topic filter to select the given modeling topic from a plurality of modeling topics described by the given modeling topic class; registering a modeling topic accessor associated with the subscribing modeling object and a modeling topic mutator associated with the subscribing modeling object; processing, through the modeling topic filter a modeling topic that is accessed through an accessor and is described by the modeling topic class, the modeling topic being received from a modeling publisher object; notifying the subscribing object of the received modeling topic through a registered modeling topic listener; and mutating the received modeling topic.

Abstract: Disclosed are methods, systems, devices, apparatus, media, design structures, platforms, and other implementations, including a method that includes receiving, by a processor-based device, configuration data representative of an initial arrangement of interlinked components forming a data application, and determining based on the configuration data, by the processor-based device, one or more complexity scores indicative of levels of complexities for one or more portions of the initial arrangement of interlinked components forming the data application. The method further includes automatically reconfiguring, by the processor-based device, the initial arrangement of interlinked components based on the computed one or more complexity scores to produce a resultant arrangement of interlinked components forming the data application.

Abstract: An apparatus, a method, and a computer program product for obtaining map update data of a region are provided. The method comprises determining an update candidate node, wherein the update candidate node is associated with a node identifier and a first node digest; sending the node identifier and the first node digest to an update data service; and receiving, from the update data service, a response containing one of node digests of the child nodes of the update candidate node at the update data service; or updated content corresponding to the update candidate node. The method may further include updating the map database based on the received response.

Abstract: Restricting use of a selected input in recovery from system failures. A testing system obtains, based on failure of a system, an indication of one or more tasks to be performed. The testing system automatically determines whether a user is to perform one or more actions to alter execution of the one or more tasks. The automatically determining is based on an indication of whether a knowledge transfer score of the user meets at least one predefined criterion. Based on knowledge transfer score meeting the at least one predefined criterion, the one or more actions are performed.

Abstract: The cloud hybrid application storage management system spans local data center and cloud-based storage and provides a unified view of content and administration throughout an enterprise. The system manages synchronization of storage locations, ensuring that files are replicated, uniquely identified, and protected against corruption. The system ingests digital media assets and creates instances of the assets with their own identification and rights and houses the identification and relationships in a CAR (Central Asset Registry). The system tracks the different instances of the assets in multiple storage locations using the CAR, which is a central asset registry that ties together disparate digital asset management repository systems (DAMs) and cloud-based storage archives in which the instances reside. While the invention treats and manages multiple files/instances independently, the CAR identifies them as related to each other.

Abstract: A method of tracking a history of firmware program updates. The method includes reading current descriptions of current application programming interfaces from a history log. The current application programming interfaces correspond to current software modules. The current software modules form a current firmware program of a target device. The method also includes accessing updated software modules and new descriptions of new application programming interfaces of an updated firmware program. The updated firmware program is created from the current firmware program. The method further includes appending the new descriptions to the current descriptions in the history log, reading the new descriptions of the new application programming interfaces from the history log, generating an updated linkage for the updated firmware program by adding new links for the new application programming interfaces, and storing the updated software modules and the updated linkage in the history log.

Abstract: A method and system may be provided for recording discussions about computer code in an integrated development environment (IDE). In some aspects, a communication channel is integrated with an IDE. Communications and discussions may be tracked and linked with specific code sections. In some aspects, a predefined graphical interface may be used in forming the communications for the communication channel.

Abstract: A system for safely reverting merges across branches in version control systems where shared history cannot be rewritten is described. A computer-implemented method, comprising: identifying a first merge base at a trunk, the first merge base merging with a branch of the trunk; identifying, at the branch, a second merge base, subsequent to the first merge base, the second merge base merging with the trunk; forming a merge base patch branch from the branch at the second merge base, the merge base patch branch including a copy of the first merge base; merging the merge base patch branch with the trunk; and merging the merge base patch branch with the branch.

Abstract: Computing systems, for example, multi-tenant systems deploy software artifacts in data centers created in a cloud platform using a cloud platform infrastructure language that is cloud platform independent. The system receives an artifact version map that identifies versions of software artifacts for datacenter entities. The system generates a master pipeline for deploying services on a target cloud platform. The master pipeline includes a change management stage comprising instructions for interacting with a change management system. The execution of the change management stage of a pipeline provides a status of deployment of one or more services to the change management system. The details recorded can be used for auditing, for example, to determine why certain change in the configuration of services of the datacenter was made.

Abstract: A code base is parsed to identify methods having changes in a code base since a last code commit. Thereafter, a call graph is traversed to identify test cases implicated by the identified methods having changes in the code base. The call graph can be a directed call graph comprising a plurality of connected nodes in which a first subset of the connected nodes are method nodes representing each method in the code base in which unidirectional edges connecting method nodes correspond to invocations by a calling method to a callee method, and in which a second subset of the connected nodes are test case nodes representing each of a plurality of available test cases to test the code base. The test case nodes are each coupled to one or more method nodes by unidirectional edges that correspond to the test case coverage of the method.

Abstract: A computer system for security of components includes at least one processor. For a new version of a component, the processor determines, based on a dataset of release events over time, a historical behavioral analysis of (i) a project that is released with prior versions of the component, and/or (ii) historical committer behavior of a committer that committed the new version of the component, and/or (iii) historical behavior of a publisher of the project. The dataset of release events includes event data collected over time regarding open source project, committers, and repository. The processor determines whether the new version of the component presents an unusual risk profile, based on the historical behavioral analysis. The processor facilitates delayed consumption of the new version of the component in response to determining that the new version of the component presents the unusual risk profile.

Abstract: Techniques involve determining a job template for executing a development job in the development environment and obtaining configuration information associated with the development job. The configuration information defines a development environment user preference for a configuration parameter. A development job instance is generated based on the job template and the configuration parameter. The development job instance is executed on code from the user to build an image for executing an application program. Rather than write code, developers may generate a development job instance including the desired configuration parameter by modifying the configuration information. Such techniques improve working efficiency of developers and maintain a common development template for use by developers. Such a technique may improve operation by imposing consistent storage application control.

Abstract: A method includes accessing a shared industrial automation project file, creating a local copy of an industrial automation project file representative of the shared industrial automation project file on a storage component accessible by the one or more processors, receiving, via a graphical user interface (GUI), an input indicative of one or more modifications to the local copy of the industrial automation project file, implementing the one or more modifications to the local copy of the industrial automation project file based on the input, identifying one or more differences between the local copy of the industrial automation project file and the shared industrial automation project file, wherein the one or more differences are associated with the one or more modifications, and presenting a notification indicative of the one or more differences between the local copy of the industrial automation project file and the shared industrial automation project file.

Abstract: For each of a plurality of commit operations to be executed for respective given code portions of a set of software code under development, at least one processing device performs a relevance analysis to identify one or more other code portions of the set of software code that each exhibits at least a threshold level of relevance to the given code portion, determines one or more code reviewers for the given code portion based at least in part on the one or more other code portions identified by the relevance analysis, assigns code review responsibilities for the given code portion to the one or more determined code reviewers, notifies the one or more determined code reviewers of the assigned code review responsibilities, and responsive to successful completion of code review by the one or more determined code reviewers, executes the commit operation for the given code portion.

Abstract: An issue tracking system (ITS) is disclosed. The ITS comprises a user interface configured to receive user input defining one or more issues and an interface module configured to interface with a source code management system (SCM) and receive from the SCM, data pertaining to linked SCM-repository events. The received data is processed to generate an order for the SCM-repository events to which the issue is linked. A display module is configured to concurrently display a plurality of issues, each issue being displayed with issue information and issues having linked SCM-repository events being displayed with linked SCM-repository event information, said linked SCM-repository event information being displayed according to the generated order.

Abstract: Methods and systems for a platform development version control system for monitoring contributors to software platform development. The methods and systems generate data analytics on contributors to software platform development using group affiliations as listed in a group directory (e.g., a corporate directory for an entity providing the software platform) as a common organizing factor. For example, by organizing the methods and systems according to the group affiliations, the methods and systems may generate data analytics on contributions of contributors within those groups, irrespective of whether or not the group members are working on the same project. The methods and systems may then provide recommendations and graphical representations based on the data analytics.

Abstract: In various example embodiments, a system and method for versioning data in an unstructured data store are presented. The method includes generating a first record in the unstructured data store based on a version of a second record in the unstructured data store. The method further includes initializing a parent version identifier of the first record based on the version of the second record. The method further includes comparing the parent version identifier of the first record to a version identifier of the second record. The method further includes determining whether the first record is consistent based on the comparison.

Abstract: A version control system implemented in software and executed by one or more processors that provides for change set integration for diverse types of objects. The system may be configured to handle a wide range of objects of different types committed to the version system by storing and/or versioning the objects, change sets, and complex relationships between objects and object dependencies. Unified support for development operations may be provided as assets under version control may optionally be deployed, rolled back, compared to a corresponding live environment, and tested thus providing for sophisticated development and operational cycles. The system provides automatic and/or semi-automatic object integration such as may be useful for continuous development and integration and feature based development.

Abstract: In some examples, a first computing device may receive, from a repository computing device, an indication of a change request including updated software located at a repository. The first computing device may receive at least one key-to-string mapping from the updated software located at the repository, and an indication of a target locale associated with the change request. The first computing device may compare a first string from the at least one key-to-string mapping and the target locale with translated strings maintained in a database to determine that a translated version of the first string translated for the target locale is absent from the database. The first computing device may receive, from a translation provider computing device, the translated version of the first string translated for the target locale, and may send the translated version of the first string to the repository computing device for association with the repository.

Abstract: Described herein is a system for providing version control across APIs. In an embodiment, an application of a client device may transmit communications to a service application API that are in a format not accepted by the service application API, using the application API. A central (or public) API may receive the communication transmitted by the application's API. The central API may identify the versions of the application's API and the service application API. The central API may format the communication based on the mapped fields, to a format accepted by the service application API. The central API 106 may forward the formatted communication to the service application.

Abstract: Methods, systems, and devices supporting joint code validation across code repositories are described. Some systems may store code across multiple code repositories, where the code repositories support repository-specific pull requests and validations. However, code stored in one repository may depend on code stored in a different repository. To accurately validate changes to such code, a system may identify a validation trigger for a first pull request (e.g., indicating one or more code changes to a first code repository), determine a second code repository or second pull request related to the first pull request, and generate a test build across the code repositories. For example, the test build may include code updates in the first code repository according to the first pull request and code from the second code repository (e.g., updated according to the second pull request). The system may perform joint validation tests on the test build.

Abstract: A system provides electronic integration and deployment of computer code in a code development network. The system may comprise a multilayered distributed ledger structure and may perform real-time source code conflict checks by combining the latest nonce from a primary distributed ledger with the genesis block of a working distributed ledger into a hash algorithm. Depending on whether the output of said hash algorithm satisfies the cryptographic challenge set by the distributed ledger system, the system may be able to detect mismatches between the source code found in a working distributed ledger and the source code found in the primary distributed ledger. Furthermore, the system may include production systems as nodes of the primary distributed ledger such that the production systems may maintain updated copies of the source code throughout the software development process.

Abstract: A system and method for associating a technical artifact and one or more business rules with one or more portions of a process flow diagram by extracting a plurality of technical artifacts from a computing system having a plurality of software applications, providing a process flow diagram having a plurality of nodes and a plurality of edges, associating one or more of the plurality of technical artifacts with one or more of the plurality of nodes of the process flow diagram, displaying the process flow diagram, and when the node is actuated, displaying the associated technical artifact.