Abstract: Disclosed herein are methods, systems, and computer-readable media for automatically generating and inserting text. In an embodiment, a method may include receiving an input text prompt comprising a prefix portion and a suffix portion. The method may also include accessing a language model based on the input text prompt, and determining a set of context parameters based on the input text prompt and the language model. The method may also include generating an output text prompt based on the set of context parameters and the language model, and inserting the output text prompt into the input text prompt.

Abstract: A computer-implemented method, a computer program product, and a computer system for dynamically altering a code execution workflow using augmented reality (AR). A computer receives, from an AR device of a user, virtual modification of a source code, where the user virtually alters the source code on the augmented realty device. A computer generates an altered execution workflow, based on a virtually altered source code created in the virtual modification. A computer overlays the altered execution workflow on the AR device. A computer executes the altered execution workflow, in response to receiving from the AR device a user request for testing the virtually altered source code. A computer displays on the augmented realty device a result of executing the altered execution workflow. A computer physically alters the source code according to the virtually altered source code, in response to receiving from the AR device satisfactory user feedback about the result.

Abstract: Indirect function call target identification in software is provided. A set of explicit data flows that pass a function address between software modules of a program is determined using an explicit data dependency analysis. A set of indirect function call targets is generated from results of the explicit data dependency analysis and a dynamic execution analysis of the program. The set of indirect function call targets is expanded by identifying similar target functions based on feature embeddings generated by a graph neural network.

Abstract: Disclosed embodiments are directed at systems, methods, and architecture for providing auto-documentation to APIs. The auto documentation plugin is architecturally placed between an API and a client thereof and parses API requests and responses in order to generate auto-documentation. In some embodiments, the auto-documentation plugin is used to update preexisting documentation after updates. In some embodiments, the auto-documentation plugin accesses an on-line documentation repository. In some embodiments, the auto-documentation plugin makes use of a machine learning model to determine how and which portions of an existing documentation file to update.

Abstract: Edit automation enhancements may be implemented in source code editors and other text editors. Provisional selections that indicate user intentions are submitted to a suggestion generator with other edit context information, to improve the quality of generated text suggestions and reduce the cognitive load on users. A provisional selection may include a highlighted completion list entry, or document text targeted by a hovering cursor, or metainformation text targeted by the hovering cursor, for example. An inline grey text suggestion driven by provisional selection may be displayed simultaneously with completion list suggestions that were created without regard to provisional selection. Suggestions driven by provisional selection may be interleaved with existing document text. Suggestions may be accepted fully in one gesture, or in parts. Suggestions may be edited by a user before being accepted, driving further suggestion refinement.

Abstract: A system and method for automatically generating cross-application dependency maps for enterprise IT environments is described. Automated code parsing techniques are used to identify dependencies between and among different business applications within the IT environment, including for both legacy and modern business applications. A thorough analysis of the enterprise-wide impact of a programming change, such as, for example, a change to the code of a legacy business application, can be conducted. There is the ability to perform canonical and customized searches of dependent elements between components of the IT environment and generate impact reports that can show how desired changes to particular applications may affect the environment. The impact of changes in a code repository, which can include documents in different programming languages that reside in a separate code environment, can be identified and analyzed.

Abstract: Automatically generating code and related artifacts such as application programming interfaces (APIs) and related documentation from an abstract model of a database. The abstract model is derived from a physical model which may be a source such as a legacy database, an entity relationship diagram, or other schema defining the data tables, objects, entities, or relationships etc. of the source. The generated code may be exposed (that is, made visible to the developer in its pre-compiled state) and further configurable and extendable. Any such extended code is maintained separately from generated code. An API and related documentation are also generated from the same abstract model.

Abstract: Enabling quick feature delivery is essential for product success and is therefore a goal of software architecture design. But how may we determine if and to what extent an architecture is “good enough” to support feature addition and modification, or determine if a refactoring effort is successful in that features may be added more easily? The applications may use Feature Space and Feature Dependency, derived from a software project's revision history that capture the dependency relations among the features of a system in a feature dependency structure matrix (FDSM), using features as first-class design elements. The applications may also use a Feature Decoupling Level (FDL) metric that may be used to measure the level of independence among features.

Abstract: A system, method, and computer-readable medium for providing documentation supporting continuous development and continuous integration for specific product lines is described. Source code from product development is received as to issues, such as bugs, defects, fixes and enhancements related to specific product lines. A determination is performed if the source code is complete or locked. Complete source code is converted to a standardized language. Another determination is performed as to whether the converted source code is compliant to a document standard. Compliant document standard source code can be consumed by an authoring environment for the documentation related to the specific product line.

Abstract: Disclosed are approaches for computationally-efficient data promulgation among devices in a network. Structured databases may comprise standardized and immutable bytes, each byte linked to a unique data field, a mutable state element, and a mutable activation element. The state element may indicate that there has been a mutation as well as a recency of the mutation. The activation element may indicate whether data pushes and/or data pulls are enabled. The state elements are configured to automatically mutate if there is a mutation in a corresponding unique data field. Each device in the network may transmit API calls as state-element requests to other entity devices in a network. The API call includes at least one byte, without any values in corresponding data fields. State elements are promulgated among devices, without sharing the data fields themselves. An optional central system maintains a record of state elements without storing data field values.

Abstract: A method of analyzing code is provided. The method includes generating an abstract representation of the code, identifying conditional statements in the abstract representation, populating a truth table for each conditional statement that has been identified with all possible outcomes of the conditional statement and assessing the truth table for each conditional statement to identify issues.

Abstract: Embodiments disclose a method and a device for processing frequency converter monitoring data and a storage medium. An embodiment of the method includes: acquiring a script file containing a monitoring parameter specifying field and a storage location; parsing the script file to acquire the storage location and the monitoring parameter specifying field and determining the monitoring parameter specified by the monitoring parameter specifying field; collecting the monitoring data corresponding to the monitoring parameter; and storing the monitoring data in the storage location. The embodiments provide a script file based processing solution for frequency converter monitoring data, without no special tracking or debugging software tool required. Thus, the implementation complexity is reduced and the service cost and time are saved.

Abstract: A computer-implemented method, computer system, and computer program product for introspection of classes within source code. A computing device receives access to object-oriented source code. The computing device parses the source code to determine one or more objects contained in the source code. The computing device determines one or more classes associated with the one or more objects. The computing device generates a class table including one or more class data points associated with the one or more determined classes. The computing device generates one or more source code methods to perform a class-level introspection based upon the generated class table.

Abstract: Systems and methods for automatically recovering from software regression in a cloud computing environment. One example method includes determining, with an electronic processor, that a batch software update has been applied to the cloud computing environment. The method includes, in response to determining that a batch software update has been applied, transmitting a problem request to an event listener server. The method includes receiving, from the event listener server, a problem statement including a stack trace. The method includes determining, based on the stack trace, a software feature indicator. The method includes transmitting the software feature indicator to a root cause analyzer. The method includes receiving, from the root cause analyzer, a change list indicator and a relevancy score associated with the change list indicator. The method includes performing a mitigation action based on the change list indicator when the relevancy score exceeds a relevancy threshold.

Abstract: Crux detection in search definition sets is provided herein. Crux detection can include generating a hierarchical representation of a search definition set. The hierarchical representation can be reduced by removing search definitions unrelated to a target search definition. The search definitions in the reduced hierarchical representation can be focused by removing inapplicable elements or operations in the search definitions. Focusing the search definitions in the reduced hierarchical representation can include removing context-irrelevant elements and/or removing search-definition-irrelevant elements. The focused reduced hierarchical representation can be analyzed to identify implementation cruxes in the search definitions. Cruxes can include performance-impacting elements of the search definitions. The cruxes can be tagged and provided for redevelopment or analysis.

Abstract: Annotating programming code by receiving a first version of programming code, determining annotations for the code according to a first machine learning model, identifying a user, altering a generative model according a persona of the user, and generating altered annotations using the altered generative model.

Abstract: A build fail of a job in a development pipeline of an application development system is analyzed. A determination as to whether the build fail affects other jobs in the development pipeline is made. In response to determining that the build fail affects at least one of the other jobs of the plurality of jobs, an alert identifying the at least one of the other jobs affected by the build fail is generated.

Abstract: A system can determine a group of changed lines in a file comprising computer-executable instructions. The system can, for the respective changed lines, produce a mapping that identifies respective tests that test the respective changed lines. The system can, from the mapping and for the respective tests, determine a merge that identifies respective ones of the respective changed lines that are tested by the respective tests. The system can, from the merge and for the respective tests of the group of tests, determine respective coverage ratios that represent respective ratios between the respective ones of the respective changed lines of the group of changed lines that are tested by the respective tests and respective total changed lines in the file. The system can select an updated group of tests from the group of tests based on the respective ratios.

Abstract: A method of ranking a plurality of parts of a software code is disclosed for identification of one or more candidate parts of the software code for alteration. The software code is associated with a change history register indicative of previous alterations of the parts of the software code. The method includes (for each of the plurality of parts of the software code) determining a plurality of constituent metrics of the part of the software code by parsing the change history register and the software code determining an alteration recency metric for the part of the software code based on the time indications of the change history register, and scaling one or more of the constituent metrics based on the alteration recency metric.

Abstract: A programming model provides a method for type inference in programming operations. Information defining one or more attributes of an operation is received, the information specifying a field including a field name and a field type identifier for each of the attributes. Constraints for the operation are determined at least based on the attributes, wherein the constraints restrict at least one of a type of input for the operation or a type of output for the operation. Information defining an input for the operation is received, and it is determined, based on the constraints and the received information defining the input, the type of output for the operation. The type of output is associated with an output for the operation.

Abstract: Systems and methods for implementing model-based application control frameworks are disclosed. In one embodiment, in an information processing apparatus comprising at least one computer processor, a method for implementing model-based application control frameworks may include: (1) breaking an application into a plurality of modules, wherein each module comprises a component of the application that is capable of running independently; (2) determining a plurality of attributes for each of the modules; (3) identifying a deployment platform for each module; (4) building an attribute model for the application based on the modules, the attributes, and the deployment platform; (5) identifying control requirements for the attribute model; (6) identifying actions to implement the control requirements; and (7) deploying the actions to implement the control requirements to the application.

Abstract: A system of one or more computers that are configured to generate documentation for microservice-based applications is disclosed. In at least one embodiment, usage information relating to actual usage by one or more users of a plurality of microservices, features extracted from user story information in a backlog tracker, and a call-context graph including information identifying calling functions and called functions in the plurality of microservices are used to generate data that is provided to a natural language generator, which uses the information to automatically generate documentation for the microservice based application.

Abstract: Methods, systems, and computer-readable storage media for receiving, by an IRFT, a commit, the commit including one or more code changes to the project, in response to receiving the commit, providing, by the IRFT, a dependency map, the dependency map defining dependencies between the project and one or more of one or more other projects, one or more packages, and one or more bundles, generating, by the IRFT, a project test set based on the dependency map, the project test set including one or more projects each having one or more features to be regression tested, and initiating, by the IRFT, execution of regression testing of features of projects included in the project test set, wherein regression testing comprises executing a sub-set of test cases based on priority.

Abstract: A compiler for a software development kit is disclosed. In some embodiments, a computer-implemented method comprises receiving source code comprising an object node having a data type definition for a code value, detecting that the data type definition of the object node includes a context-dependent data type, where the context-dependent data type is dependent on at least one other data type, determining a corresponding value for each one of the other data type(s) based on the detecting that the data type definition includes the context-dependent data type, and generating a runtime instance of a software solution based on the source code, where the generating the runtime instance comprises assigning the corresponding value for each other data type as a single list ID for the object node, and the single list ID for the object node is configured to be used to determine a dedicated value of the code value.

Abstract: Systems and methods for building and testing software projects within a virtual computing environment of a computing resource service provider, providing for gathering, reporting, and summarization of test results generated by test runs executed as part of the build process are disclosed. A user makes requests to a build service provided by the computing resource service provider which automates building and testing of program code for software modules and software projects including such modules. The build service receives the requests and allocates physical computing resources, such as usage of processors, memory, storage drives, computer network interfaces, and other components of hardware computing devices within a virtual computing environment to attempt to build the software modules and report results of tests performed during the build attempts. The user may supply program code to be built without otherwise needing to manage the virtual computing resources allocated to complete the requested tasks.

Abstract: An automated portfolio-rationalization module of an application-portfolio management system selects and applies a set of consolidation decisions in order to reduce complexity of and maximize return on investment of a portfolio of software applications. The system identifies consolidation decisions for each application based on that application's technical quality and business quality and computes the cost to apply each decision. The system then organizes nonconflicting subsets of these decisions into opportunities, where each opportunity contains a set of triplets that each identifies one of the decisions and its associated cost. Non-conflicting subsets of these opportunities are further combined into feasible opportunity sets. The system compares the returns on investment that would be generated by applying each of these opportunity sets to the portfolio.

Abstract: The present disclosure relates to systems, methods, and computer readable medium for automatically managing API documentation and code generation. The disclosure provides an IDE plug-in that may import a machine readable reference documentation file from a documentation database, and create automatically generated code from the machine readable reference documentation file. Generally, the IDE plug-in may then allow a developer to validate their project back against the machine readable reference documentation file to ensure that all expected code is present in the project. This may allow the developer to ensure that the project properly meets the functional objectives intended for the API, before their implementation is deployed.

Abstract: Methods, systems, and computer-readable storage media for generating a call graph representative of a service mesh including software systems and extension applications, the software systems including a first software system that is configured to publish a first event and a second software system configured to receive first API calls, the extension applications including a first extension application configured to consume the first event and, in response to the first event, transmit first API calls, determining a first cardinality representative of a ratio of first events to first API-calls, receiving monitoring data representative of frequencies of the first event occurring during production use of the first software system, simulating production use of the service mesh by generating a set of frequencies of first API calls based on the call graph, the monitoring data, and the first cardinality, and displaying simulation results including the set of frequencies of the first API calls.

Abstract: According to examples, an apparatus may include a processor that may generate automated and dynamic fail-fast testing pipelines that are efficiently executed to quickly identify tests for which changes to components such as an application will likely fail. The processor may train a classifier to predict whether changes to the application will fail a test procedure and use the classifier to generate machine-learned predictions of test outcomes to generate failure probabilities. The testing pipeline may be dynamically re-ordered based on the failure probabilities. The processor may also group the test procedures into lifecycle stages. Historical performance data may be used to identify time-limits by which to complete the test procedures of each lifecycle stage. Thus, the generated dynamic testing pipelines may be generated based on the likelihood of failures and test procedure duration.

Abstract: An intermediate representation of a workflow of one or more modules may be generated to decouple language implementations of the one or more modules. In response to receiving a workflow of one or more modules, the workflow may be analyzed to determine an optimal implementation language for each of the one or more modules to thereby reduce effects of data marshalling. An intermediate representation of the workflow that is configured to decouple any implementation languages associated with the one or more modules may be generated. To allow for decoupling, the intermediate representation may be written in a declarative language. The generated intermediate representation may then be compiled to generate an executable program that corresponds to the workflow and is implemented in the determined optimal language for each of the one or more modules.

Abstract: Aspects of the disclosure relate to self-correcting dependent software upgrades. A computing platform may scan a software source code and parse release notes associated with the source code. The computing platform may identify a code modification to be performed on dependent source code, and may identify a code segment of the dependent source code. Then, the computing platform may retrieve, based on a machine learning model, a code fix for the code segment, and a test case associated with the code modification. The computing platform may update the code segment by applying the code fix, and may merge the updated code segment with the dependent source code. Then, the computing platform may run the test case on the modified source code. Then, the computing platform may determine an outcome for the modified source code, and may initiate, based on the outcome, an action related to the dependent source code.

Abstract: Described herein is a computer-implemented method for deploying a software product to an environment. The method comprises defining an environment lock for the environment, the environment lock being configured to selectively prevent deployment of a software product to the environment. The method further comprises receiving a request from a requesting entity to deploy a designated software product to the environment, determining a status of the environment lock, and either permitting or preventing the deployment of the designated software product to the environment by reference to the determined status of the environment lock.

Abstract: A method of container and image scanning includes receiving, by a processing device initiating a scan process to scan containers executing functionality of multiple applications. The method further includes, for each container of the containers, identifying portions of an application image instance of the container, the portions corresponding to previously-scanned clean layers of the application image instance, scanning, by the processing device in accordance with the scan process, remaining portions of the application image instance not associated with the previously-scanned clean layers, and responsive to a clean result of the scanning of the remaining portions of the application image instance, terminating, by the processing device, the scan process for the container and allowing the container having the application image instance to execute.

Abstract: The present disclosure relates to a method for a software development system, the software development system comprising a code repository storing source code. The method comprises: receiving at the code repository an additional code; receiving at one or more documentation repositories documentation information for documenting the source code; generating corpus-based semantic word embeddings for code and documentation words of the source code and the documentation information; using the word embeddings for mapping by the software development system the source code to corresponding documentation; storing the mapping of the source code to the corresponding documentation.

Abstract: Providing an enhanced continuous integration (CI)/continuous delivery (CD) build script debugging environment is disclosed. In one example, the CI/CD build script debugging environment inserts a breakpoint within a CI/CD build script that includes one or more build script steps. During execution of the CI/CD build script within the CI/CD build script debugging environment, execution is paused at the breakpoint, and a language-specific debugging environment suitable for debugging the next build script step is automatically identified and launched. Some examples may also provide that the CI/CD build script debugging environment allows the user to resume execution of the CI/CD build script within the CI/CD build script debugging environment without further pauses, and/or to “step over” a build script step by executing the build script step within the CI/CD build script debugging environment without launching a language-specific debugging environment.

Abstract: A method, a computer program product, and a computer system for determining a location using street view images. A mobile device obtains an image captured by the mobile device, obtains a set of street view images, and obtains a first graph of the image captured by the mobile device and a plurality of second graphs of the set of the street view images. The first graph includes nodes representing interest points in the image captured by the mobile device, and the plurality of the second graphs includes nodes representing interest points in the set of the street view images. The mobile device determines a location of the mobile device, based on relevance between the first graph and the plurality of the second graphs.

Abstract: A system recommends the refactoring of microservices. The system determines a segments similarity score based on comparing first code segments, associated with a first microservice in an application, against second code segments, associated with a second microservice in the application. The system determines whether the segments similarity score satisfies a segments similarity threshold. The system determines microservices similarity scores based on comparing a size of similar code segments in the first code segments and the second code segments against sizes of the first microservice and the second microservice, if the segments similarity score satisfies the segments similarity threshold. The system determines whether any microservices similarity score satisfies a microservices similarity threshold. The system outputs a recommendation to merge the first microservice with the second microservice, if any microservices similarity score satisfies the microservices similarity threshold.

Abstract: A software-testing device includes a conversion unit configured to convert a PLC program for operating a programmable logic controller into a general-purpose language program described in a general-purpose programming language, and a test execution unit configured to perform a test on the general-purpose language program.

Abstract: Systems and methods are disclosed for connection multiplexing in a parallel processing environment. An example method includes requesting, responsive to a request to perform multiple database operations in a single transaction, a connection identifier for a physical connection to the database, providing the connection identifier to each of a plurality of workers, and performing the multiple database operations using the plurality of workers. Each worker may obtain a work item from a work queue, initiate a database request for the work item, and provide the database request to a database server. The database request represents one of the multiple database operations and includes the connection identifier. The database server may determine that the connection identifier corresponds to the physical connection, add the request to a connection queue associated with the physical connection, and execute requests from the connection queue against the database via the physical connection.

Abstract: A software instruction code repair system comprising an instruction code example pool. The example pool comprises a set of good instruction code examples and a set of bad instruction code examples. The software instruction code repair system further comprises a sequence-to-sequence (seq2seq) network that is configured to generate a corrected instruction code example, based on one example of the set of bad instruction code examples. The software instruction code repair system further comprises a discriminator configured to randomly select one of the corrected instruction code example and one instruction code example of the set of good instruction code examples to produce a selected instruction code example. The discriminator is further configured to make a determination that the selected instruction code example is most likely taken either the instruction code example pool or the seq2seq network.

Abstract: A browse node page is addressed by its path. As a result, a web crawler may be more likely to find the browse node than the corresponding parameter-based search page. The browse node may be further distinguished from a search result page by the use of a title or header metatag that indicates information about the browse node and distinguishes the browse node from a general search result page. The number of combinations of keywords, categories, and key-value pairs makes the creation of a browse node for every possible combination prohibitive in all but the simplest applications. Methods and systems to identify which search result pages should be converted to browse nodes are disclosed herein.

Abstract: A method and system for improving access to search results are provided in the disclosure herein. Aspects of this disclosure minimize the delay in accessing network content by priming certain regularly viewed content (e.g., a web search home page or a search results page) in an invisible browser instance. As the user accesses the content prerendered in the invisible browser instance, a new instance of the prerendered content is created to facilitate future accesses to the network content (e.g., future search queries).

Abstract: A compiler for a software development kit is disclosed. In some embodiments, a computer-implemented method comprises receiving source code comprising an object node having a data type definition for a code value, detecting that the data type definition of the object node includes a context-dependent data type, where the context-dependent data type is dependent on at least one other data type, determining a corresponding value for each one of the other data type(s) based on the detecting that the data type definition includes the context-dependent data type, and generating a runtime instance of a software solution based on the source code, where the generating the runtime instance comprises assigning the corresponding value for each other data type as a single list ID for the object node, and the single list ID for the object node is configured to be used to determine a dedicated value of the code value.

Abstract: Methods and apparatuses are described for automated analysis, categorization, and behavior prediction of computer scripts using rules-based pattern matching. A server receives from a client device, a request for analysis of a process flow decision. The server identifies computer scripts that execute to generate the process flow decision. For each identified computer script: the server identifies text patterns in the computer script and categorizes the computer script based upon the identified patterns; the server converts the computer script into an expression tree data structure; the server traverses the expression tree to determine logical expressions that return a true result; the server parses each logical expression that returns a true result to identify parameters that contribute to the true result; the server generates a response to the request for analysis of the process flow decision and transmits the response to the request to the client computing device.

Abstract: Aspects extend to methods, systems, and computer program products for transforming data manipulation code into data workflow. Data manipulation code for a data science process is written in a data manipulation programming language. The data manipulation code defines input instructions, data manipulation instructions, and output instructions. A learning module automatically transforms the data manipulation code into a data workflow representative of the data science process. The level of detail for a data workflow can be tailored for an intended audience and/or for subsequent editing with an editor program (e.g., a drawing program). Aspects of the invention address the disconnection between designing a data science process and documenting the data science process. The creation of data workflows is automated, virtually eliminating manual operations and providing significant productive gains for data scientists, data engineers, developers, and program managers.

Abstract: In one embodiment, a computer-implemented method comprises receiving, at a server computer, a plurality of commit records of a source code management system (SCM), wherein a first commit record of the plurality of commit records includes a first parent commit identifier (ID) that identifies a parent commit record of the first commit record; storing, in one or more data repositories, a full commit record for each commit record of the plurality of commit records; in response to determining that the first commit record includes a parent commit ID, storing, in the one or more data repositories, a first partial commit record for the first commit record, wherein the first partial commit record comprises a partial commit record that is identified by the first parent commit ID; generating and submitting a database query to a digital data repository associated with the SCM, based on determining that a partial commit record is stored in the one or more digital repositories, and receiving first partial commit update dat

Abstract: Flaws in dependencies of deployed applications are identified. In one embodiment, a list of dependencies used by a deployed application that is deployed on the deployment platform is obtained. Each dependency of the list of dependencies is mapped with a flaws database, wherein the flaws database comprising an indication of known flaws for different dependencies and different versions thereof. Based on such mapping, one or more flaws in the deployed application are determined. The determination is performed externally to the deployment platform and without executing a monitoring process thereon.

Abstract: Methods, systems, and computer program products for search engine optimization techniques are provided herein.

Abstract: One embodiment provides a method of identifying discrepancies of an application operating on multiple operating platforms, the method including: utilizing at least one processor to execute computer code that performs the steps of: obtaining a first source code associated with an application of a first operating platform, the first source code including at least one feature of the application; generating, based on the first source code, a first context graph; obtaining a second source code associated with the application of a second operating platform, the second source code including the at least one feature of the application; generating, based on the second source code, a second context graph; comparing the first and second context graph; and identifying, based on the comparison, at least one discrepancy. Other variants and embodiments are broadly contemplated herein.

Abstract: Systems, methods, and computer-readable media are described for external storage and organization of documentation for computer-executable source code. An executable program is provided that receives a selected codebase as input and generates or updates a code comment database corresponding thereto that provides a structured framework for documenting the codebase externally from the codebase. The executable program provides a user with the capability to add and/or edit comments for each structure in a codebase that is represented in a corresponding code comment database. A user can navigate through a code comment database using a user interface that includes a visual representation of a nested hierarchy of functions of the codebase. The visual representation can be manipulated by a user to provide an identification of arguments, variables, called functions, or the like for each function. Code documentation can also be displayed in association with the visual representation.