Artificial intelligence simulation of operating systems and command line interfaces of operating systems

Abstract

Mechanisms are provided for simulating an operating system. For each operating system, the mechanism trains a corresponding artificial intelligence (AI) computer model that learns a pattern of input features of inputs to the operating system and corresponding responses from the operating system through machine learning training. A request to emulate the requested operating system and an emulation input to emulate processing thereof by the requested operating system are received. An AI computer model corresponding to the requested operating system is executed on the analog input to simulate processing of the analog input to generate an analog response. The analog response is returned as an analog output of the requested operating system in response to the input.

Description

Background Technology

[0001] This application generally relates to an improved data processing apparatus and method, and more specifically to an improved computing tool for artificial intelligence simulation of an operating system and its command-line interface, as well as improved computing tool operation / function.

[0002] The Command Line Interface (CLI) is a text-based user interface used to run programs, manage computer files, and interact with the computer. Commands entered into the CLI are executed by the computer. For example, the CLI can provide a command prompt of type "c:", and a user can enter commands such as "\Users\myuser> cd" to "change directory" (cd) and navigate to various folders stored on the storage system. Similarly, a command of type "c:\> npm install mysoftware" can be used to install the software program "mysoftware" via the package manager "npm". A command-line interpreter or command-line processor is used to interpret and execute commands entered via the CLI.

[0003] CLI has been available since the 1960s. Various operating systems, such as Linux® (a registered trademark of Linus Torvalds), GNU® (a registered trademark of the Free Software Foundation), Microsoft Windows® (a registered trademark of Microsoft Corporation), IBM AIX® (a registered trademark of IBM Corporation), Android® (a registered trademark of Google, LLC), iOS® (a registered trademark of Cisco), Solaris, etc., provide CLIs. However, the commands recognized by various CLIs, and the options associated with those commands, can vary significantly from one operating system CLI to another. That is, each operating system has its own command-line interpreter or command-line processor that recognizes different commands and / or different options for those commands. Therefore, even if a command and / or its options may work correctly with one CLI, it may not work correctly with other CLIs.

[0004] While the CLI may not be as popular as it once was due to the advent of graphical user interfaces (GUIs), it remains an essential tool for software developers, network administrators, system administrators, and information technology (IT) professionals. Web server-based operations can be associated with the CLI, and many automation tools require the CLI to perform multiple tasks. In fact, some programming and maintenance tasks may not have a GUI and must rely on the CLI. Furthermore, to obtain IT certifications for various technologies, users must demonstrate their proficiency with the corresponding CLI. Summary of the Invention

[0005] In one exemplary embodiment, a method is provided for simulating a computer implementation of an operating system in a data processing system. The method includes: for each of one or more operating systems, training a corresponding artificial intelligence (AI) computer model, the AI ​​computer model being trained via machine learning to learn patterns of input features of inputs to the operating system and corresponding responses from the operating system. The method also includes receiving a request from a requesting computing device to simulate a requested operating system, and receiving simulated input from the requesting computing device to simulate processing of the requested operating system on that input. The method further includes retrieving an AI computer model corresponding to the requested operating system, and executing the retrieved AI computer model on the simulated input to simulate processing of the simulated input by the requested operating system, thereby generating a simulated response. Furthermore, the method includes returning the simulated response to the requesting computing device as a simulated output in response to the input from the requested operating system.

[0006] In other exemplary embodiments, a computer program product is provided, comprising a computer-usable or readable medium having a computer-readable program. When executed on a computing device, the computer-readable program causes the computing device to perform various operations and combinations thereof, as outlined in the exemplary embodiments of the method.

[0007] In yet another exemplary embodiment, a system / apparatus is provided. This system / apparatus may include one or more processors and memory coupled to the one or more processors. The memory may include instructions that, when executed by the one or more processors, cause the one or more processors to perform various operations and combinations thereof outlined with respect to the exemplary embodiments of the method. Attached Figure Description

[0008] The invention, its preferred mode of use, and further objects and advantages will be best understood by reading the following detailed description of exemplary embodiments in conjunction with the accompanying drawings, wherein:

[0009] Figure 1 This is an example diagram illustrating the differences in the command-line interface (CLI) supported by the operating system for example CLI commands;

[0010] Figure 2 This is an example diagram of a distributed data processing system environment in which aspects of exemplary embodiments can be implemented and in which at least some computer code involved in performing the inventive method can be executed;

[0011] Figure 3 This is an example diagram of an Intelligent Command-Line Interface Simulated Robot (ICSB) framework and system according to an exemplary embodiment;

[0012] Figure 4 This is an example flowchart illustrating example operations of the ICSB framework and system according to an exemplary embodiment;

[0013] Figure 5 This is an example diagram illustrating the simulation of commands in a simulated operating system CLI, according to an exemplary embodiment.

[0014] Figure 6 This is an example diagram illustrating, according to an exemplary embodiment, sample simulated CLI output or results generated based on input commands to the ICSB framework and system; and

[0015] Figure 7 This is an example diagram of the ICSB data structure over a time period of an ICSB session according to an exemplary embodiment. Detailed Implementation

[0016] Exemplary embodiments provide improved computing tools and improved computing tool operations / functions for artificial intelligence simulation of an operating system and its command-line interface (CLI). For the purposes of the following description, the use of an operating system CLI simulation is used as an example illustrating the mechanism of the exemplary embodiments. However, it should be understood that the mechanism of the exemplary embodiments is not limited to the simulation of a specific command-line interface, but can be implemented to simulate various operations of the operating system. That is, instead of requiring the machine learning of patterns of input characteristics of commands specific to the command-line interface as simulated input, the artificial intelligence (AI) computer model of the exemplary embodiments can also learn patterns of input characteristics for other types of input to the operating system and simulate the corresponding operating system response to such input. Therefore, the invention is not limited to the command-line interface and the simulated processing of command-line interface commands and options by the simulated operating system.

[0017] As mentioned above, there are many different operating systems, such as Linux® (a registered trademark of Linus Torvalds), GNU® (a registered trademark of the Free Software Foundation), Microsoft Windows® (a registered trademark of Microsoft Corporation), IBM AIX® (a registered trademark of IBM Corporation), Android® (a registered trademark of Google, LLC), iOS® (a registered trademark of Cisco), Solaris, etc. Each operating system has its own CLI and supported commands, as well as options for those commands. Therefore, while a user may be proficient in one operating system and its CLI, this does not mean that the user will be proficient in other operating systems and their CLIs. Furthermore, if a user wants to learn the CLIs of different operating systems, they need to set up physical hardware and individually install / configure each operating system of interest to learn the CLI for each. This requires a significant amount of setup and configuration time, which can be difficult for beginners and users with limited technical knowledge. Additionally, attempting to rent a cloud server to provide the operating system environment and corresponding CLI can be an expensive process, and rented servers often do not accurately reflect the individual user's real-world operating system environment. This is particularly problematic for individuals seeking different IT certifications who may lack access to the devices and software that enable CLI and do not have the resources to rent cloud-based servers that run operating systems to enable CLI.

[0018] Figure 1 This is an example diagram illustrating the differences in CLI support across operating systems for sample CLI commands. In the example shown, the "grep" command can be used on several different operating systems, such as Linux® and AIX®, but not every operating system supports the same options for the "grep" command. The "grep" command is used to search a file for a specific character pattern and display all lines containing that pattern. For example, "grep Apple test.txt" will display all lines in the file "test.txt" that contain the character pattern "Apple". Many CLI commands can use options to set further criteria, filters, or controls on the command, and different CLIs may enable different parts of these options. In the example shown, the option "-m" is used. In the Linux® operating system, this option is used to specify the maximum number of results to return; for example, the option "-m 4" indicates that the first 4 results should be returned from the search.

[0019] like Figure 1As shown, the option "-m" is defined only in the command-line interpreter of the Linux® operating system and not in the command-line interpreter of the AIX® operating system. Instead, to achieve a similar result in AIX® to the Linux® command "grep -m4 Peach test.txt", you must execute the command "grep Peach test.txt | head -4". To identify such differences between CLIs, for educational purposes, certification, etc., you must find and install two different operating systems, Linux® and AIX®, and then run the command "grep -m 4 Peach test.txt" with the "-m" option in both operating system command-line interfaces to demonstrate that the AIX® operating system does not support such an option, and then identify other commands and options that will achieve similar results through manual effort.

[0020] Exemplary embodiments provide mechanisms for simulating operating systems through an artificial intelligence computer model trained using machine learning, and in some exemplary embodiments, for simulating the command-line interface (CLI) of an operating system, the artificial intelligence computer model learning the operating system and / or CLI's responses to input feature patterns. In this way, the mechanisms of the exemplary embodiments can simulate various operating systems and / or CLIs without the user having access to all the resources required to implement the operating system and / or CLI on a computing device. Furthermore, the exemplary embodiments facilitate comparisons of operating systems and / or CLIs with respect to their operation on a given input, again without requiring access to the actual software and hardware resources required to execute an instance of the operating system and its CLI on a computing device.

[0021] The following description provides examples of embodiments of the invention, and variations and substitutions may be made in other embodiments. Several examples will now be provided to further clarify various aspects of this disclosure.

[0022] Example 1: A method for simulating an operating system in a data processing system is provided. The method includes: for each of one or more operating systems, training a corresponding artificial intelligence (AI) computer model, the AI ​​computer model being trained via machine learning to learn patterns of input characteristics of inputs to the operating system and corresponding responses from the operating system. The method also includes receiving a request from a requesting computing device to simulate a requested operating system, and receiving simulated inputs from the requesting computing device to be processed by the requested operating system. The method further includes retrieving an AI computer model corresponding to the requested operating system, and executing the retrieved AI computer model on the simulated inputs to simulate the processing of the simulated inputs by the requested operating system to generate a simulated response. Additionally, the method includes returning the simulated response to the requesting computing device as a simulated output of the inputs from the requested operating system.

[0023] The aforementioned limitations advantageously enable the simulation of operating systems without specific computing environments and operating system resources (i.e., libraries, operating system memory, and processor resources, etc.). Instead, the operating system is simulated by an AI computer model. This enhances the identification of operating system performance differences between operating systems with similar inputs and allows for more efficient evaluation of operating system performance by simulating operating system responses rather than having to install and configure the operating system on various computing devices with potentially different environmental configurations.

[0024] Example 2: A limitation of any of Examples 1 and 3-11, where the corresponding AI computer model is a command-line interface (CLI) computer model that maps the input characteristic patterns of commands input to the CLI of the operating system to the corresponding CLI responses. In some exemplary embodiments, the request is a request to simulate the CLI of the requested operating system, and where the input to be simulated by the requested operating system is a command to the CLI. Therefore, these foregoing limitations advantageously enable the AI ​​computer model to simulate the response output of the operating system's command-line interface to input commands without requiring specific computing environments and operating system resources for implementing an actual operating system and command-line interface. Instead, the command-line interface is simulated by the AI ​​computer model. Thus, a user can specify the operating system they wish to simulate for the command-line interface and the commands they wish to simulate, and the AI ​​computer model will simulate the command-line interface to be presented without actually executing the operating system and command-line interface. This facilitates the simulation of operating systems and command-line interfaces through AI chatbots or conversational bots.

[0025] Example 3: A limitation of any of Examples 1-2 and 4-11, where the simulated input is a command-line interface (CLI) for the requested operating system, and the simulated output is a simulated CLI response generated by the retrieved AI computer model simulating the requested operating system. These limitations advantageously enable the AI ​​computer model to simulate the response output of the operating system's command-line interface to the input command. The command-line interface is simulated by the AI ​​computer model. Therefore, the user can specify the operating system they wish to simulate for the command-line interface and the commands they wish to simulate, and the AI ​​computer model will simulate the command-line interface to be presented without actually executing the operating system and the command-line interface. This facilitates the learning of operating systems and command-line interfaces because one can quickly switch between the operating system and the command-line interface to see how each operating system and command-line interface responds to a given command and how their responses differ. For example, it can be determined which operating systems support specific commands and options, and which do not. In some cases, a side-by-side comparison of the operating system and command-line interface responses can be provided, thereby facilitating this learning.

[0026] Example 4: A limitation of any of Examples 1-3 and 5-11, where a simulated response is returned to the requesting computing device as a simulated output of the requested operating system in response to input, including returning a simulated CLI response in a simulated user interface that mimics the command-line interface of the requested operating system. Therefore, the requester can operate as if interacting with a CLI, but the CLI is simulated through an AI computer model. Thus, the requester does not need access to the specific hardware and software resources used to implement the actual operating system and corresponding CLI, but can still obtain results from the simulated operation of the operating system and CLI.

[0027] Example 5: A limitation of any of Examples 1-4 and 6-11, where the pattern of input characteristics includes the pattern of operating system commands input to the operating system's command-line interface and the corresponding options for those operating system commands. Therefore, the requester can simulate various operating systems and command-line interfaces for various combinations of commands and options to determine how various operating systems respond to commands / options. In some cases, options may not be supported by all operating systems, and by simulating the responses of the operating system and command-line interface, differences in operating system and command-line interface operation with respect to these options can be quickly identified without installing and reconfiguring computing devices to execute various operating systems and command-line interfaces.

[0028] Example 6: A limitation of any of Examples 1-5 and 7-11, where one or more operating systems include multiple operating systems, training the AI ​​computer model involves training a separate AI computer model for each different operating system among the multiple operating systems, and each AI computer model is trained to simulate the same set of command-line interface commands, but relative to the corresponding operating system among the multiple operating systems. Therefore, the requester can simulate various operating systems and command-line interfaces for various combinations of commands and options to determine how various operating systems respond to the same commands / options for educational and development purposes. That is, it can be determined which commands and options are supported by various operating systems and command-line interfaces, and software can be developed based on this knowledge. Furthermore, for user authentication, it may be necessary for users to be familiar with various operating systems and their command-line interfaces, and the simulation of operating systems and command-line interfaces based on AI computer models facilitates a fast and efficient comparison of multiple operating systems without actually configuring the computing system to execute the operating system with all its configured resources.

[0029] Example 7: Restrictions on any of Examples 1-6 and 8-11, wherein the AI ​​computer model is trained based on machine learning processing of a training dataset comprising a set of command-line interface commands, options for those commands, and expected command-line interface outputs for the commands and options based on an ingested corpus of source documents (including operating system design documents, support centers, and support pages). In this way, the AI ​​computer model learns from the corpus how various operating systems and command-line interfaces process and respond to a variety of commands and options in natural language and / or structured documents and information sources. These restrictions advantageously configure the AI ​​mechanisms of the exemplary embodiments to specifically simulate how a particular operating system responds to a particular input and how the operating system's command-line interface processes such input, in order to provide accurate simulated responses. This again enhances the simulation of the operating system and command-line interface and facilitates a better understanding of the performance of the operating system and command-line interface.

[0030] Example 8: A limitation of any of Examples 1-7 and 9-11, where the request is a natural language request submitted via a chatbot interface, specifying the requested operating system and the simulated input to be processed by the requested operating system. Therefore, a user can submit a natural language request simulating an operating system and / or command-line interface through a conversation with the chatbot, and the request can be processed, with the operating system / command-line interface being simulated on the user's natural language request. This facilitates a better user experience and does not require the user to have access to an actual instance of an operating system and / or command-line interface. That is, a user can simply enter a request to simulate a specific operating system and / or command-line interface using natural language, specifying the command they wish to simulate, and the AI-based computer model system will respond with a simulated response in a manner as if the command were processed by an actual operating system and / or command-line interface.

[0031] Example 9: A limitation of any of Examples 1-8 and 10-11, where a user profile is received specifying a subset of operating systems to be simulated, and training of a corresponding AI computer model is performed for each operating system specified in the user profile. In this way, users can specify the operating systems they want to simulate, and different AI computer models can be trained for each operating system the user wishes to simulate. Furthermore, these limitations advantageously allow users to customize the simulation of the operating system and / or command-line interface based on the AI ​​computer model according to their specific needs; that is, the operating system, command-line interface, and commands they wish to simulate. This allows each user to have their own customized configuration of the AI ​​computer model and the simulated operating system and / or command-line interface.

[0032] Example 10: A limitation of any of Examples 1-9 and 11, where the user profile further specifies, for a subset of the operating system, the range of commands to be learned by the training of the corresponding AI computer model, and a default set of environment variables to be used when simulating a subset of the operating system. In this way, users can specify the types of commands they want to simulate, and can specify the environment variables used to simulate those commands. Therefore, users can customize the simulation to the specific computing environment they expect to operate in. This advantageously provides the ability to simulate different computing environments and different commands without needing access to those different computing environments and actual instances of the operating systems and command-line interfaces within those environments.

[0033] Example 11: A limitation of any of Examples 1-10, wherein user feedback is received in response to a simulated response, indicating whether the simulated response is correct or incorrect, and the training of the retrieved AI computer model is updated based on the user feedback. Therefore, the user can inform the system whether the training is correct or needs modification through user feedback, and this information can be used to make the training of the AI ​​computer model more accurately match what the user expects from the operating system response and / or command-line interface response. This advantageously allows for continuous training of the AI ​​computer model to improve its performance and the simulation results generated by the AI ​​computer model.

[0034] Example 12: A system comprising one or more processors and one or more computer-readable storage media, the one or more computer-readable storage media collectively storing program instructions that, when executed by the one or more processors, are configured to cause the one or more processors to perform a method according to any of the examples in Examples 1-11. The foregoing limitations advantageously enable a system comprising one or more processors to perform and achieve the advantages described in relation to Examples 1-11.

[0035] Example 13: A computer program product includes one or more computer-readable storage media and program instructions commonly stored on the one or more computer-readable storage media, the program instructions including instructions configured to cause one or more processors to perform a method according to any of the examples in Examples 1-11. The foregoing limitations advantageously enable computer program products having program instructions configured to cause one or more processors to execute and implement the description relating to Examples 1-11.

[0036] Example 14: A method, system, or computer program product for simulating a computer implementation of one or more operating systems. The method, system, or computer program product includes: for each of the one or more operating systems, training a corresponding artificial intelligence (AI) computer model, the AI ​​computer model learning patterns of input characteristics of inputs to the operating system and corresponding responses from the operating system through machine learning training. The method, system, or computer program product further includes: receiving a request from a requesting computing device to simulate a requested operating system. The method, system, or computer program product further includes: receiving simulated input from the requesting computing device to be processed by the requested operating system. The method, system, or computer program product includes: retrieving an AI computer model corresponding to the requested operating system. Additionally, the method, system, or computer program product includes: executing the retrieved AI computer model on the simulated input to simulate the processing of the simulated input by the requested operating system, thereby generating a simulated response. Furthermore, the method, system, or computer program product returns the simulated response to the requesting computing device as a simulated output of the requested operating system in response to the input.

[0037] Furthermore, the method, system, or computer program product includes: simulating input as commands of the command-line interface (CLI) of the requested operating system, wherein the simulated output is a simulated CLI response generated by simulating the requested operating system based on a retrieved AI computer model. Additionally, the method, system, or computer program product includes: returning the simulated response to the requesting computing device, at least as simulated output of the requested operating system in response to the input, by returning the simulated CLI response in a simulated user interface that mimics the command-line interface of the requested operating system.

[0038] The examples above advantageously realize the benefits described in connection with Examples 1, 3, and 4. Thus, for example, a user can access an interface simulating an operating system command-line interface without needing to install and configure an operating system. Instead, a user can request a simulation of a specific operating system and be presented with a simulated command-line interface. The user can specify the commands they wish to simulate, and one or more AI computer models simulate the command-line interface's response to the commands and present it in the simulated command-line interface. All of this can be accomplished without actually implementing the requested operating system, as it is performed using an AI computer model that has learned how different operating systems respond to command-line interface commands and options.

[0039] As described above, the illustrative embodiments provide an improved computing tool and improved computing tool operation / function that learns a set of CLIs through a machine learning process and simulates the learned CLIs, enabling the simulated CLIs to dynamically respond to user input based on a knowledge base of command-line responses and patterns of CLI commands associated with those responses. Therefore, users can design, learn, and practice CLIs within a user-preferred virtualized operating system without setting up physical hardware and installing / configuring an actual operating system, or incurring resources to rent cloud servers or other hardware providing the OS and CLI of interest. The illustrative embodiments can be used to provide CLI simulations that aid in user training and education (such as for information technology (IT) certification). Furthermore, the illustrative embodiments provide simulated CLIs that allow users to dynamically switch between different simulated CLIs in real-time, or to present multiple different simulated CLIs substantially simultaneously, to perceive the differences in how different CLIs handle the same commands.

[0040] Using the mechanisms of illustrative embodiments, a framework and system are defined to support the simulation of operating systems, particularly Intelligent Command Line Interface (CLI) Simulated Robots (ICSBs) and their corresponding operations / functions. This framework and system include several distinct components, including an ICSB server that operates to provide a simulated CLI to ICSB clients. The ICSB server also includes an ICSB manager that manages various ICSB data structures, ICSB standards, and user profiles; an ICSB learner that learns patterns from CLI command and option inputs and corresponding responses from the CLI; an ICSB parser that operates to parse command input from ICSB clients and simulate the CLI based on the command input; and an ICSB adjuster that operates to update the CLI through machine learning based on user feedback. The operation of these components will be described in more detail below.

[0041] Additionally, an ICSB data structure is defined to handle ICSB operations, wherein the ICSB data structure is updated over time to include information emulated by one or more CLIs representing one or more operating systems of the user. According to some illustrative embodiments, the ICSB data structure includes user, operating system (OS), and CLI characteristic data, including user identifier (UserID), operating system name (OSName), configuration information for the operating system and user identifier (Configuration[OSName][UserID]), a list of CLIs for the operating system invoked by the user (CLIList[OSName]), a CLI log for the operating system and user identifier that maintains a log of commands entered by the user corresponding to the user ID (CLILog[OSName][UserID]), a user command (UserCMD) specifying the latest command entered by the user into the emulated CLI, command options (CMDOptions) specifying the latest command options entered by the user into the emulated CLI, command output (CMDOutput) generated by the emulated CLI for the latest entered command, and an error state specifying whether an error occurred while the CLI was processing the entered command, such as whether the CLI does not support a particular command or option. As users interact with the ICSB server through their ICSB clients, these features in the ICSB data structure are populated and updated over time, such that some features may not be populated during the first time interval but may be populated and updated during subsequent time intervals, as will be described in more detail below. Therefore, the ICSB data structure is a dynamic data structure that is populated and updated based on user input via the ICSB client and the results of CLI simulations performed during the user's session with the ICSB server.

[0042] The framework and system operate to allow users to configure and customize ICSB standards, such as supported operating systems, the scope of the CLI (i.e., how many and which commands and options to include in the simulated CLI), default environment variables (e.g., locale (e.g., the user's spoken language), IP address, CPU / GPU / memory, storage type and size, available computing tools, etc.). The aforementioned ICSB Manager operates to provide an interface through which such configuration and customization can be performed, and can manage and maintain ICSB profiles. ICSB profiles include ICSB data structures for client sessions between the user's ICSB client computing device and the ICSB server, as well as, if necessary, a history of such ICSB data structures and ICSB standards. The ICSB Manager can define and maintain user profiles for each user, where such profiles can specify information about the specific operating system the user wishes to emulate via the ICSB server, which subset of commands and options the user wants to emulate, and CLI emulation history information that can be used and / or viewed for purposes such as education, training, and certification.

[0043] The ICSB learner within the ICSB framework and systems learns a set of CLI commands, options, and expected outputs across multiple operating systems through machine learning operations. Machine learning operations can be performed based on knowledge acquired from corpora including various sources and documents such as Redbooks, support centers, websites (e.g., Wikipedia), man pages, design documents, etc. The ICSB learner ingests corpora containing CLI information from various sources, which can include structured or unstructured data, and learns patterns in CLI commands / options and their corresponding CLI responses or outputs. For example, if the ICSB standard specifies that CLI commands, options, and expected outputs should be learned from Linux... ® By learning commands of the type "grep" from user documentation, Wikipedia, man pages, design documents, etc., the ICSB learner learns the association between "grep" and the corresponding CLI output. For example, if the grep command is entered, the CLI responds with file lines that have a text pattern matching the string specified in the grep command. Therefore, the input pattern is associated with the output pattern.

[0044] ICSB client computing devices can be configured to act as ICSB monitors, monitoring user requests used to emulate an operating system and / or its CLI. The ICSB monitor can receive user requests emulating a specified operating system and / or CLI via a user interface and can also send these requests to the ICSB server. The ICSB server can present an interface through the ICSB monitor through which requests can be submitted. For example, the ICSB server and ICSB monitor can present a chatbot-type interface or other natural language interface through which users can submit natural language requests, such as "Emulate AIX using the -m option". ® The ICSB server's ICSB parser can parse requests and extract various key elements of the request via the ICSB extractor, including the user ID, operating system name, command name, associated options, etc. In doing so, the ICSB extractor and ICSB parser can identify the requested operating system and the ICSB identifier of the command, and then send it to an operating system emulation agent that implements a CLI based on the association between input command patterns and output or response patterns learned from the ICSB learner. The operating system emulation agent dynamically or "on the fly" emulates the user-specified operating system according to the ICSB profile, user profile, and ICSB standards, and executes the CLI simulator to simulate the CLI response of the specified command with associated options. In this way, the CLI simulator generates the expected output or response of a mapping to a user-specified command for a user-specified operating system CLI.

[0045] The ICSB rendering engine, which runs on the client computing device as part of the ICSB client, presents the expected output or response in simulated user command output. The ICSB rendering engine can also simulate the CLI, allowing the user to input commands via a simulated CLI, which can then be translated into a request sent to the ICSB server. This request is then processed as described above to simulate the CLI based on a learned correlation between the patterns of CLI commands / options and the patterns of CLI output. Similarly, the simulation results can be presented to the requester as a simulated user interface mimicking the command-line interface of an operating system.

[0046] It should be understood that this CLI simulation may return output or results that the user does not believe represent the actual correct CLI response in the user's computing environment. The ICSB rendering engine can provide user interface elements through which the user can specify whether the returned CLI output or result is correct according to their understanding, and provide feedback on the user's expected results for the input commands and options. This user feedback can be provided to the ICSB server, which sends the user feedback to the ICSB adjuster. The ICSB adjuster adjusts the machine learning model that maps the pattern of input commands and options to the pattern of CLI output or results, updating the machine learning model to correct any discrepancies between the content generated by the CLI simulation based on the machine learning model and what the user expects to see as the correct CLI response to the input commands and options.

[0047] Therefore, exemplary embodiments provide improved computing tools and improved computing tool operations / functions, specifically referring to simulating the command-line interface (CLI) of an operating system through machine learning of the CLI responses to command and option inputs. Exemplary embodiments automatically learn the association between patterns in the input commands and options of various operating system CLIs and patterns in the CLI responses or outputs. This mapping of patterns then represents the CLI pattern for each operating system CLI, which can be maintained in a CLI model repository. The CLI models in the CLI model repository can then be dynamically applied to requests from users to simulate the CLI of a specified operating system for specified commands and options, thereby generating simulated CLI responses or outputs. All of this is done without actually installing the operating system and configuring a specific computer execution environment for it.

[0048] The exemplary ICSB framework and system provide a cost-effective solution for tasks requiring different operating system command-line interfaces, such as education, training, and certification. In other words, by emulating and virtualizing the operating system command-line interface, the exemplary embodiments can significantly reduce the hardware and software costs required for these tasks.

[0049] Furthermore, the ICSB framework and system of the exemplary embodiments facilitate accessibility to various operating system command-line interfaces. That is, the virtualized operating system command line can be accessed from anywhere with a data network connection (e.g., an internet connection) because the ICSB framework and system can be provided as a service via one or more cloud computing systems, server computing systems, etc. This makes it easier for individuals and organizations to access CLI emulation to perform their educational, training, and certification tasks, as well as any other tasks that may require CLI access.

[0050] The ICSB framework and system of the exemplary embodiment are customizable because the virtualized operating system command-line interface can be modified to meet specific needs and requirements. That is, users can dynamically select the operating system command-line interface as needed and switch between them "on the fly" according to their requirements. This allows for a more tailored learning experience because the ICSB framework and system respond dynamically to user requests without requiring long wait times for the installation and configuration of different operating systems and their command-line interfaces.

[0051] The exemplary ICSB framework and system provide users with a safe and reliable environment for experimentation and learning without the risk of damaging physical hardware or critical data. The exemplary ICSB framework and system can be easily scaled to accommodate multiple users and different operating systems because the ICSB framework and system can learn the CLI mode of the requested operating system and the mapping between CLI input and output modes. This makes the ICSB framework and system an important educational, training, certification, and experimental tool for large organizations.

[0052] The ICSB framework and systems can be integrated into various cloud computing products, such as IBM Cloud, to provide users with an on-demand virtualized operating system command-line interface. This is a cost-effective and scalable solution for organizations that need to run different operating systems for their applications. The ICSB framework and systems can be used in the development and testing of artificial intelligence (AI) models (such as IBM Watson) and applications that require different operating systems and configurations, improving the accuracy and reliability of these models. The ICSB framework and systems can be used to simulate and test various cybersecurity threats and vulnerabilities, such as via IBM Security, helping organizations improve their security measures and prevent cyberattacks. The ICSB framework and systems can be used by researchers to experiment with different operating systems and configurations, such as via IBM Research, leading to the development of new technologies and innovations.

[0053] Before proceeding with the discussion of various aspects of the exemplary embodiments and the improved computer operations performed by the exemplary embodiments, it should first be understood that throughout the description, the term "mechanism" will be used to refer to the elements of the invention that perform various operations, functions, etc. As used herein, a "mechanism" can be an implementation of a function or aspect of an exemplary embodiment, such as a device, process, or computer program product. In the case of a process, the process is implemented by one or more devices, apparatuses, computers, data processing systems, etc. In the case of a computer program product, logic represented by computer code or instructions embodied in or thereon is executed by one or more hardware devices to implement a function or perform an operation associated with a particular "mechanism." Therefore, the mechanism described herein can be implemented as dedicated hardware, software executed on hardware (thus configuring the hardware to implement the specific functions of the invention, which the hardware would otherwise be unable to perform), software instructions stored on a medium such that the instructions can be readily executed by the hardware, thereby specifically configuring the hardware to perform the functions and specific computer operations described herein, a process or method for performing the functions, or any combination of the foregoing.

[0054] The terms “a,” “at least one,” and “one or more” may be used in this description and claims to describe specific features and elements of exemplary embodiments. It should be understood that these terms and phrases are intended to indicate the presence of at least one specific feature or element in a particular exemplary embodiment, but multiple features or elements may also be present. That is, these terms / phrases are not intended to limit the description or claims to the presence of a single feature / element, nor do they require the presence of multiple such features / elements. Rather, these terms / phrases only require the presence of at least one feature / element, while multiple such features / elements may also be within the scope of the description and claims.

[0055] Furthermore, it should be understood that if the term "engine" is used herein with respect to the description of embodiments and features of the invention, it is not intended to limit any particular technical implementation to accomplishing and / or performing actions, steps, processes, etc., attributable to and / or performed by the engine, but rather to limit the "engine" to a computer technology implementation where its actions, steps, processes, etc., are not performed as mental processes or by human effort, even if the engine can work with human input or provide output for human or mental consumption. An engine is implemented as any one or more software, dedicated hardware, and / or firmware, or a combination thereof, executed on hardware, specifically configured to perform a specified function. The hardware may include, but is not limited to, the use of a processor in conjunction with appropriate software loaded or stored in machine-readable memory and executed by the processor, thereby specifically configuring the processor for a dedicated purpose including one or more functions of one or more embodiments. Furthermore, unless otherwise stated, any names associated with a particular engine are for convenience of reference and are not intended to limit to a particular implementation. Additionally, any function attributable to an engine may be performed similarly by multiple engines, combined with and / or combined with functions of the same or different types of engines, or distributed across one or more engines in various configurations.

[0056] Furthermore, it should be understood that the following description uses various examples of various elements of the exemplary embodiments to further illustrate exemplary implementations of the exemplary embodiments and to aid in understanding the mechanisms of the exemplary embodiments. These examples are intended to be non-limiting and are not limited to various possibilities for implementing the mechanisms of the exemplary embodiments. For those skilled in the art, it will be apparent from this description that many other alternative implementations of these various elements, in addition to, or replacing, the examples provided herein, can be utilized without departing from the spirit and scope of the invention.

[0057] Various aspects of this disclosure are described by narrative text, flowcharts, block diagrams of computer systems, and / or block diagrams of machine logic included in embodiments of a computer program product (CPP). Regarding any flowchart, depending on the technology involved, operations may be performed in a different order than that shown in a given flowchart. For example, again according to the technology involved, two operations shown in consecutive flowchart blocks may be performed in reverse order, as a single integrated step, simultaneously, or in a manner that at least partially overlaps in time.

[0058] Computer Program Product Embodiment (“CPP Embodiment” or “CPP”) is a term used in this disclosure to describe any collection of one or more storage media (also referred to as “media”) collectively included in a collection of one or more storage devices, the collection of one or more storage devices collectively including machine-readable code corresponding to instructions and / or data for performing computer operations specified in a given CPP claim. A “storage device” is any tangible device capable of holding and storing instructions used by a computer processor. Without limitation, a computer-readable storage medium can be an electronic storage medium, a magnetic storage medium, an optical storage medium, an electromagnetic storage medium, a semiconductor storage medium, a mechanical storage medium, or any suitable combination of the foregoing. Some known types of storage devices that include these media include: magnetic disks, hard disks, random access memory (RAM), read-only memory (ROM), erasable programmable read-only memory (EPROM or flash memory), static random access memory (SRAM), compact disc read-only memory (CD-ROM), digital versatile disc (DVD), memory sticks, floppy disks, mechanical encoding devices (such as punch cards or pits / platforms formed in the main surface of the disk), or any suitable combination of the foregoing. Computer-readable storage media, as used in this disclosure, should not be construed as storing transient signals themselves, such as radio waves or other freely propagating electromagnetic waves, electromagnetic waves propagating through waveguides, optical pulses through fiber optic cables, electrical signals transmitted through wires, and / or other transmission media. As those skilled in the art will understand, data is typically moved at certain incidental points in time during the normal operation of the storage device, such as during access, defragmentation, or garbage collection; however, this does not render the storage device transient, as the data is not transient when it is stored.

[0059] It should be understood that certain features of the invention described in the context of individual embodiments for clarity may also be provided in combination in a single embodiment. Conversely, various features of the invention described in the context of individual embodiments for brevity may also be provided individually or in any suitable sub-combination.

[0060] This invention can be a computing system specifically configured with hardware and / or software specifically configured to implement the specific mechanisms and functions described herein, a method implemented by the specifically configured computing system, and / or a computer program product comprising software logic loaded into the computing system to specifically configure the computing system to implement the mechanisms and functions described herein. Whether described as a system, method, or computer program product, it should be understood that the exemplary embodiments described herein specifically refer to improved computing tools and methods implemented by such improved computing tools. Specifically, the improved computing tools of the exemplary embodiments specifically provide intelligent command-line interface simulating a robot. The improved computing tools implement mechanisms and functions such as machine learning with command and option patterns having CSI outputs or responses, simulation of CSI for various operating systems, and processing command input from the user via such simulation to generate simulated responses or outputs, without the need to install and configure a corresponding operating system. Humans cannot actually perform these operations outside of a technical environment or without the aid of a technical environment (such as mental processes). The improved computing tools provide practical applications of the method, which at least in the fact that the improved computing tools can dynamically simulate various operating system command-line interfaces for users for purposes such as education, training and certification.

[0061] Figure 2 This is an example diagram of a distributed data processing system environment in which aspects of exemplary embodiments can be implemented and in which at least some of the computer code involved in performing the inventive method can be executed. That is, computing environment 200 includes examples of environments for executing at least some of the computer code involved in performing the inventive method, such as an Intelligent Command-Line Interface Simulator Robot (ICSB) framework and system 300. In addition to the ICSB framework and system 300, computing environment 200 includes, for example, a computer 201, a wide area network (WAN) 202, an end-user device (EUD) 203, a remote server 204, a public cloud 205, and a private cloud 206. In this embodiment, computer 201 includes a processor set 210 (including processing circuitry 220 and a cache 221), a communication structure 211, volatile memory 212, persistent storage 213 (including an operating system 222 and the ICSB framework and system 300, as described above), a peripheral device set 214 (including a user interface (UI) device set 223, storage 224, and an Internet of Things (IoT) sensor set 225), and a network module 215. Remote server 204 includes remote database 230. Public cloud 205 includes gateway 240, cloud orchestration module 241, host physical machine set 242, virtual machine set 243, and container set 244.

[0062] Computer 201 can take the form of a desktop computer, laptop computer, tablet computer, smartphone, smartwatch or other wearable computer, mainframe computer, quantum computer, or any other form of computer or mobile device now known or to be developed in the future capable of running programs, accessing networks, or querying databases such as remote database 230. As is well known in the field of computer technology, and depending on that technology, the execution of computer-implemented methods can be distributed among multiple computers and / or multiple locations. On the other hand, in this presentation of computing environment 200, the detailed discussion focuses on a single computer, specifically computer 201, to keep the presentation as simple as possible. Computer 201 can reside in the cloud, even... Figure 2 It is not shown that it is in the cloud. On the other hand, unless explicitly instructed otherwise, computer 201 is not required to be in the cloud.

[0063] Processor set 210 includes one or more computer processors of any type now known or to be developed in the future. Processing circuitry 220 may be distributed across multiple packages, such as multiple cooperating integrated circuit chips. Processing circuitry 220 may implement multiple processor threads and / or multiple processor cores. Cache 221 is memory located within the processor chip package and is typically used for data or code that should be available for fast access by the threads or cores running on processor set 210. Cache memory is typically organized into multiple levels based on its relative proximity to the processing circuitry. Alternatively, some or all of the cache in the processor set may be located “off-chip.” In some computing environments, processor set 210 may be designed to work with qubits and perform quantum computing.

[0064] Computer-readable program instructions are typically loaded onto computer 201 to cause the processor set 210 of computer 201 to perform a series of operational steps to implement a computer-implemented method, such that the instructions thus executed instantiate the method specified in the flowcharts and / or narrative descriptions of the computer-implemented method included in this document (collectively, the “inventive method”). These computer-readable program instructions are stored in various types of computer-readable storage media, such as cache 221 and other storage media discussed below. The program instructions and associated data are accessed by processor set 210 to control and direct the execution of the inventive method. In computing environment 200, at least some of the instructions for performing the inventive method may be stored in the ICSB framework and system 300 in persistent storage 213.

[0065] Communication structure 211 is a signal transmission path that allows various components of computer 201 to communicate with each other. Typically, this structure consists of switches and conductive paths, such as switches and conductive paths forming buses, bridges, physical input / output ports, etc. Other types of signal communication paths can be used, such as fiber optic communication paths and / or wireless communication paths.

[0066] Volatile memory 212 is any type of volatile memory now known or to be developed in the future. Examples include dynamically typed random access memory (RAM) or statically typed RAM. Typically, volatile memory is characterized by random access, but this is not necessary unless explicitly indicated. In computer 201, volatile memory 212 is located in a single package and is internal to computer 201; however, alternatively or additionally, volatile memory may be distributed across multiple packages and / or located externally relative to computer 201.

[0067] Persistent storage 213 is any form of non-volatile storage for a computer, now known or to be developed in the future. The non-volatility of this storage means that the stored data is retained regardless of whether power is supplied to the computer 201 and / or directly to the persistent storage 213. Persistent storage 213 may be read-only memory (ROM), but typically at least a portion of persistent storage allows for data writing, data deletion, and data rewriting. Some common forms of persistent storage include disks and solid-state storage devices. Operating system 222 may take several forms, such as various known proprietary operating systems or operating systems employing an open-source portable operating system interface type with a kernel. The code included in the ICSB framework and system 300 generally includes at least some of the computer code involved in performing the inventive methods.

[0068] Peripheral device set 214 includes a collection of peripheral devices for computer 201. Data communication connections between peripheral devices and other components of computer 201 can be implemented in various ways, such as Bluetooth connectivity, near field communication (NFC) connectivity, connections made by cables (such as Universal Serial Bus (USB) type cables), plug-in connections (e.g., secure digital (SD) cards), connections made via local area communication networks, and even connections made via wide area networks such as the Internet. In various embodiments, UI device set 223 may include components such as displays, speakers, microphones, wearable devices (such as glasses and smartwatches), keyboards, mice, printers, touchpads, game controllers, and haptic devices. Storage 224 is an external storage device, such as an external hard drive, or a pluggable storage device, such as an SD card. Storage 224 can be persistent and / or volatile. In some embodiments, storage 224 may take the form of a quantum computing storage device for storing data in the form of qubits. In embodiments where computer 201 requires substantial storage (e.g., where computer 201 locally stores and manages a large database), this storage can be provided by peripheral storage devices designed to store very large amounts of data, such as a storage area network (SAN) shared by multiple geographically distributed computers. The IoT sensor set 225 consists of sensors that can be used in IoT applications. For example, one sensor could be a thermometer, while another could be a motion detector.

[0069] Network module 215 is a collection of computer software, hardware, and firmware that allows computer 201 to communicate with other computers via WAN 202. Network module 215 may include hardware such as a modem or Wi-Fi transceiver, software for packetizing and / or depacketizing data for transmission over the communication network, and / or web browser software for transmitting data over the Internet. In some embodiments, the network control and network forwarding functions of network module 215 are performed on the same physical hardware device. In other embodiments (e.g., embodiments utilizing software-defined networking (SDN), the control and forwarding functions of network module 215 are performed on physically separate devices, such that the control function manages several different network hardware devices. Computer-readable program instructions for performing the methods of the invention can typically be downloaded to computer 201 from an external computer or external storage device via a network adapter card or network interface included in network module 215.

[0070] WAN 202 is any wide area network (e.g., the Internet) capable of transmitting computer data over non-local distances using any technology known now or developed in the future for transmitting computer data. In some embodiments, WAN 202 may be replaced by and / or supplemented by a local area network (LAN) designed to transmit data between devices located in a local area, such as a Wi-Fi network. WAN and / or LAN typically include computer hardware such as copper transmission cables, optical fiber transmissions, wireless transmissions, routers, firewalls, switches, gateway computers, and edge servers.

[0071] End User Equipment (EUD) 203 is any computer system used and controlled by an end user (e.g., a customer of the enterprise operating computer 201) and can take any of the forms discussed above in connection with computer 201. EUD 203 typically receives helpful and useful data from the operation of computer 201. For example, assuming computer 201 is designed to provide recommendations to the end user, these recommendations are typically transmitted from network module 215 of computer 201 to EUD 203 via WAN 202. In this way, EUD 203 can display or otherwise present the recommendations to the end user. In some embodiments, EUD 203 can be a client device, such as a thin client, a thick client, a mainframe computer, a desktop computer, etc.

[0072] Remote server 204 is any computer system that provides at least some data and / or functionality to computer 201. Remote server 204 can be controlled and used by the same entity operating computer 201. Remote server 204 represents a machine that collects and stores helpful and useful data used by other computers, such as computer 201. For example, if computer 201 is designed and programmed to provide recommendations based on historical data, that historical data can be provided to computer 201 from a remote database 230 of remote server 204.

[0073] Public cloud 205 is any computer system that can be used by multiple entities, providing on-demand availability of computer system resources and / or other computing capabilities (especially data storage (cloud storage) and computing power) without direct active management by the user. Cloud computing typically leverages resource sharing to achieve scalability consistency and economy. Direct and active management of the computing resources of public cloud 205 is performed by the computer hardware and / or software of cloud orchestration module 241. The computing resources provided by public cloud 205 are typically implemented by virtual computing environments running on various computers constituting host physical set 242, which is the entire domain of physical computers in and / or available to the public cloud 205. Virtual computing environments (VCEs) typically take the form of virtual machines from virtual machine set 243 and / or containers from container set 244. It should be understood that these VCEs can be stored as images and can be transferred between various physical machine hosts as images or after the VCEs are instantiated. Cloud orchestration module 241 manages the transfer and storage of images, deploys new instantiations of VCEs, and manages active instantiation of VCE deployments. Gateway 240 is a collection of computer software, hardware, and firmware that allows public cloud 205 to communicate via WAN 202.

[0074] Now, we will provide some further explanation of Virtualized Computing Environments (VCEs). A VCE can be stored as an "image." A new active instance of a VCE can be instantiated from this image. Two common types of VCEs are virtual machines and containers. A container is a VCE that uses operating system-level virtualization. This refers to an operating system feature where the kernel allows multiple isolated user-space instances, called containers, to exist. From the perspective of the programs running within them, these isolated user-space instances typically appear as actual computers. Computer programs running on a regular operating system can utilize all the resources of that computer, such as connected devices, files and folders, network shares, CPU power, and quantifiable hardware capabilities. However, programs running within a container can only use the contents of the container and the devices allocated to the container; this is a characteristic known as containerization.

[0075] Private cloud 206 is similar to public cloud 205, except that computing resources are available only to a single enterprise. While private cloud 206 is depicted as communicating with WAN 202, in other embodiments, private cloud may be completely disconnected from the Internet and accessible only via a local / private network. A hybrid cloud is a combination of multiple clouds of different types (e.g., private, community, or public cloud types) typically implemented by different vendors. Each of the multiple clouds remains a separate and discrete entity, but the larger hybrid cloud architecture is bound together by standardization or proprietary technology that enables orchestration, management, and / or data / application portability across the multiple component clouds. In this embodiment, public cloud 205 and private cloud 206 are both part of a larger hybrid cloud.

[0076] like Figure 2 As shown, one or more computing devices (e.g., computer 201 or remote server 204) may be specifically configured to implement the ICSB framework and system 300. The configuration of the computing device may include providing dedicated hardware, firmware, etc., to facilitate the execution of the operations described herein with respect to illustrative embodiments and the generation of output. The configuration of the computing device may also, or alternatively, include providing software applications stored in one or more storage devices and loaded into the memory of the computing device (such as computing device 201 or remote server 204) to cause one or more hardware processors of the computing device to execute the software applications configuring the processor to perform the operations described herein with respect to illustrative embodiments and generate output. Furthermore, any combination of dedicated hardware, firmware, software applications executing on hardware, etc., may be used without departing from the spirit and scope of the illustrative embodiments.

[0077] It should be understood that once a computing device is configured in one of these ways, it becomes a dedicated computing device specifically configured to implement the mechanisms of the exemplary embodiments, and not a general-purpose computing device. Furthermore, as described below, the implementation of the mechanisms of the exemplary embodiments improves the functionality of the computing device and provides command-line interface functionality that facilitates machine learning of input patterns for commands and options, and dynamically simulates useful and specific results for command-line interfaces used in various operating systems based on user requests and user-specified commands and options.

[0078] It should be understood that, despite Figure 2 An example embodiment in which the ICSB framework and system 300 are implemented through a single computing system is shown, but exemplary embodiments are not limited thereto. Rather, in other exemplary embodiments, the components of the ICSB framework and system 300 and their operation / functions may be distributed across multiple computing devices or systems (such as multiple server computing devices) without departing from the spirit and scope of the invention. Figure 2 This is merely an example of one possible implementation using a sample computing system.

[0079] Figure 3 This is an example diagram of an Intelligent Command-Line Interface Simulated Robot (ICSB) framework and system according to an exemplary embodiment. Figure 2 The operational components shown can be implemented as dedicated computer hardware components, computer software executing on computer hardware (and then configured to perform specific computer operations attributed to that component), or any combination of dedicated computer hardware and configured computer software. It should be understood that even if the input can be provided by a human (e.g., a simulated request for the operating system command-line interface, commands and options to be simulated via the command-line interface, etc.), these operational components automatically perform attributed operations without human intervention, and the resulting output can assist humans (e.g., simulated command-line interface responses to user-inputted commands and options). This invention is particularly directed to automated operating computer components aimed at improving the way users can experience operating systems and their command-line interfaces without explicitly having the hardware and installing / configuring the system of interest, and providing specific solutions for implementing command-line interfaces and their responses to specific combinations of commands and options, as well as the subsequent simulation of user-specified commands and options for these command-line interfaces. These operations cannot be actually performed by humans as mental processes, and they are not directed at organizing any human activity.

[0080] like Figure 3 As shown, the Intelligent Command Line Interface (CLI) Simulated Robot (ICSB) framework and system 300 includes an ICSB server 310 and an ICSB client 360. The ICSB server 310 may include components implemented on one or more computing systems / devices, which can be accessed by a client computing system implementing the ICSB client 360 via one or more data networks 370. The ICSB client 360 (which may be an application or a plugin for a browser application running on a client computing device 380) includes an ICSB monitor 362 and an ICSB rendering engine 364. The ICSB client 360 includes logic to notify the ICSB server 310 that a user 390 on the client computing device 380 wants to invoke the CLI simulation of the ICSB server 310.

[0081] ICSB server 310 includes ICSB manager 320, ICSB learner 330, ICSB parser 340, and ICSB regulator 350. ICSB manager 320 also includes ICSB profile engine 322 and user profile store 328, wherein ICSB profile engine 322 operates in conjunction with ICSB data structure 324 and ICSB standard store 326. ICSB profile engine 322 includes logic for creating, maintaining, updating, and removing user profiles in ICSB data structure 324, ICSB standard 326, and user profile store 328. ICSB manager 320 operates dynamically and automatically in response to user input from ICSB client 360 and the results of CLI simulations generated by ICSB server 310 and returned to ICSB client 360. ICSB data structure 324 stores various operating system, CLI, and user characteristics, which are dynamically and automatically populated during CLI simulation sessions between ICSB client 360 and ICSB server 310.

[0082] ICSB Standard 326 specifies requirements for storage to support CLI emulation, such as the operating systems to be supported, the scope of CLI emulation (e.g., the number and specific commands and options to be emulated), and default environment variables (e.g., local, IP address, CPU / GPU / memory, storage type and size, tools, etc.). ICSB Standard 326 can be modified by administrators or other authorized personnel who wish to change the CLI emulation provided by ICSB Server 310. For example, when supporting a new operating system command-line interface, information about the new operating system's command-line interface can be added to ICSB Standard 326.

[0083] User profile 328 may store user-specific information, similar to ICSB standard 326. For example, user profile 328 may store information about the specific operating system the user wishes to emulate via ICSB server 310, the subset of commands and options the user wants to emulate, and CLI emulation history information, which may be used and / or viewed, for example, for educational, training, and certification purposes. User profile 328 may specify additional criteria for CLI emulation, such as different operating system command-line interfaces to emulate than those supported by ICSB standard 326. For example, if a user wishes to emulate a command-line interface for an operating system different from that supported by ICSB standard 326, additional operating system CLI requirements can be specified in user profile 328, and ICSB learner 330 can operate to automatically learn the CLI model of the operating system CLI requested by the user.

[0084] ICSB learner 330 includes machine learning logic to automatically learn the association between patterns of input CLI commands and options and patterns of CLI output from various CLI data sources and documents 332, to generate one or more CLI models stored in CLI model repository 334. ICSB learner 330 can ingest structured and unstructured data, such as electronic documents from various sources, such as Wikipedia, operating system user documentation, man pages (“man” is a command that returns the definition of a subsequently specified command; for example, “man grep” gives the definition of the command “grep”), design documents, red books, support center web pages, etc. For example, as... Figure 1 As shown, one source of the documentation may include a structured table of options supported by various operating system command lines. Figure 1 The table shown indicates whether an option (e.g., "-m") and the operating system AIX®, Linux (GNU), or Solaris supports the option, with blank entries indicating that the option is supported and "N" entries indicating that the option is not supported.

[0085] The ICSB learner 330 ingests various data sources and learns commands and options supported by various operating systems, as well as the corresponding results returned by the command-line interface interpreter as the result of those commands and options, through machine learning processing of structured and unstructured data. That is, patterns of commands and options can be extracted from the ingested data, and patterns of command-line interface interpreter results can also be extracted and mapped to corresponding commands and options. In this way, the ICSB learner 330 learns CLI models that associate patterns of commands and options with patterns of CLI results. The ICSB learner 330 can perform this operation for each individual operating system CLI to be modeled. Each CLI model generated by this machine learning by the ICSB learner 330 can be stored in a CLI model repository 334. The ICSB learner 330 also provides logic for retrieving stored CLI models from the CLI model repository 334 on demand for use by the CLI simulator 348 in performing CLI simulations.

[0086] ICSB parser 340 includes logic for parsing user requests received via ICSB client 360, ICSB monitor 362 (e.g., via an AI chatbot, such as Chat GPT, or other natural language text-based interfaces), and ICSB server 310. ICSB parser 340 is capable of parsing input from user 390 to ICSB client 360 and extracting features from it, where these extracted features correspond to one or more features present in the previously discussed ICSB data structure 324. For example, features may include user, operating system (OS), and CLI feature data similar to those maintained in ICSB data structure 324. As described above, ICSB data structure 324 includes features such as user identifier (UserID), operating system name (OSName), configuration information for the operating system and user identifier (Configuration[OSName][UserID]), a list of CLIs for the operating system invoked by the user (CLIList[OSName]), a CLI log for the operating system and user identifier (CLILog[OSName][UserID]) (which maintains a log of commands entered by the user corresponding to the user ID for each operating system), user command (UserCMD) specifying the latest command entered by the user into the simulated CLI, command options (CMDOptions) specifying the latest command options entered by the user into the simulated CLI, command output (CMDOutput) generated by the simulated CLI for the latest entered command, and error state (Error State) specifying whether an error occurred in the CLI when processing the entered command (e.g., the CLI does not support a particular command or option). Some of these features can be obtained from the results of CLI simulation rather than directly from user input, and can be populated by the ICSB server based on ICSB server operations, rather than specifically parsing and extracting features from user input.

[0087] As an example, ICSB server 310 can implement an AI chatbot with a mechanism of an exemplary embodiment that enhances and extends the functionality of the AI ​​chatbot, specifically enabling it to learn the mapping between command-line interface commands / options and command-line interface output or results, and to simulate a CLI request based on user-specified files and commands / options using the generated command-line interface (CLI) model. ICSB parser 340 parses such requests received from user 390 via its ICSB client 360 and identified by ICSB monitor 362 as requests simulating an OS and command line, and invokes ICSB extractor 342 to extract features from the user request, including ICSB identifier 344 identifying a specific operating system command-line interface, command-line commands and options, and features of other ICSB data structures. For example, ICSB extractor 342 can identify features in user input received from ICSB client 360, including user identifier, OS name, configuration information for the OS, user commands, command options, etc.

[0088] ICSB parser 340 also operates to invoke operating system (OS) emulation agent 346, which operates to generate an emulation of the operating system environment specified by user 390 in a user request from ICSB client 360 based on features extracted from ICSB extractor 342. In response to user 390 inputting a command to emulate from ICSB client 360, OS emulation agent 346 invokes CLI emulator 348 to emulate a command-line interface interpreter based on a CLI model from CLI model repository 334 corresponding to the emulated OS. The emulation can be further configured, for example, by ICSB standard 326 and user profile 328, and features corresponding to the CLI emulation and the user input to the CLI emulation can be used to update ICSB data structure 324 via ICSB manager 320 and ICSB profile engine 322.

[0089] The CLI model implemented in CLI simulator 348 maps the characteristic patterns of command input to corresponding CLI responses or outputs. Therefore, CLI simulator 348 simulates the CLI interpreter's response to commands and any options (if any) and returns results. In some cases, commands and options may not be supported by a specific OS and CLI interpreter. In such cases, CLI simulator 348 can return results indicating that a particular command and / or option is not supported and providing additional help about which commands and / or options are supported, such as a list of supported options. ICSB parser 340 then returns the results of the commands / options (as generated by the CLI simulation) to ICSB client 360, which renders the results to the user of the client computing device via ICSB rendering engine 364.

[0090] For example, user 390 can request ICSB service 310 to emulate Red Hat® (a registered trademark of Red Hat, Inc.) Linux® (a registered trademark of Linus Torvalds) by entering a natural language request of type “In Red Hat Linux” through their ICSB client 360, and can enter a sample file, such as “test.txt”. In the example provided herein, the “test.txt” file is a text file whose first 6 lines are of type “Apple-1” to “Apple-6”, and the next 6 lines are of type “Peach-1” to “Peach-6”, as shown in the accompanying figure to be referenced later. User 390 can also enter command-line interface commands and options that user 390 wishes to emulate, such as “grep -m 1 Apple test.txt”, which retrieves the first line of the test.txt file, which includes the string “Apple”. ICSB server 310 will emulate the CLI and provide the emulation result of “Apple-1” in this example. However, at no point in this emulation is the user required to install and configure the requested operating system or provide a device for running the requested operating system. In fact, user 390 can emulate an operating system and its command-line interface that do not even exist on the user's client computing device 380.

[0091] It should be understood that ICSB client 360 user 390 can submit a request at any point to dynamically switch the emulated operating system and command-line interface, and can even switch back and forth between various operating systems in real time. ICSB server 310 processes such requests and automatically and dynamically changes the OS emulated by OS emulation agent 346 and the corresponding CLI emulation executed by CLI emulator 348 based on the corresponding CLI model from CLI model repository 334. This results in virtually no perceptible latency because there is no requirement to install and configure an actual operating system on actual computer hardware.

[0092] The results of the CLI simulation are generated in response to commands entered by user 390 into ICSB rendering engine 364 and returned by ICSB server 310 to ICSB client 360. ICSB rendering engine 364 emulates a command-line interface, making user 390 perceive that they are interacting with the actual command-line interface of a real operating system, when in fact they are interacting with a simulation. ICSB rendering engine 364 receives CLI simulation responses from ICSB server 310 and renders them in the simulated command-line interface displayed to user 390. User 390 can enter commands and options into the simulated command-line interface and send them as CLI simulation requests to ICSB server 310, which then uses the CLI simulation and corresponding CLI model to simulate the results of the CLI interpreter for the user-entered commands and returns these results as CLI simulation responses to ICSB client 360.

[0093] In some cases, user 390 may find the results generated by CLI simulator 348 and provided to ICSB client 360 inaccurate. In this case, user 390 can provide user feedback through user interface elements provided by ICSB rendering engine 364 or subsequent natural language input to, for example, an AI chatbot interface. The user feedback can then be processed by ICSB regulator 350 to adjust the CLI model in CLI model repository 334. That is, ICSB regulator 350 can use user feedback as the basis for retraining the CLI model based on the user's input commands. In this retraining, the mapping between the weights or input feature patterns of the CLI model's nodes and the CLI simulation results can be updated to reduce errors in the CLI simulation results.

[0094] Therefore, as described above, the exemplary embodiments provide improved computing tools and improved computing tool operations / functions to simulate command-line interfaces, eliminating the need for users to access the necessary hardware and software to install and configure operating systems in order to utilize those operating systems' command-line interfaces. This is significant for many different education, training, certification, research, and product development industries. Through the mechanisms of the exemplary embodiments, users no longer need to expend resources to acquire the necessary hardware to run all the various operating systems they wish to utilize, and no longer need to spend time and effort to install and configure the various operating systems they wish to utilize in order to achieve their education, training, certification, research, and product development goals.

[0095] For example, without the mechanism of the exemplary embodiment, a user must ensure they have the necessary hardware capacity to process the most resource-intensive operating systems, then obtain a license for each operating system they wish to use, then obtain the software for each operating system, then install and configure each operating system individually and sequentially, and then utilize the various operating systems as desired. This is an extremely resource-intensive and time-intensive operation, as it can take hours to switch between operating systems, including uninstalling one, installing a new one, and configuring it for the computing environment to utilize the new operating system, and this needs to be done every time a user wants to utilize a different operating system and its command-line interface.

[0096] The mechanism of the exemplary embodiment virtualizes the operating system and command-line interface using AI machine learning tools, so that users do not need any new or additional hardware or software other than installing a plugin in their existing web browser application on their client device, because the operating system and command-line interface are simulated at ICSB server 310 and the CLI simulation results are returned to ICSB client 360. This also allows for instantaneous, automatic, and dynamic switching between different operating systems.

[0097] In some exemplary embodiments, the ICSB client 360 can facilitate the presentation of multiple windows representing command-line interface simulations of different operating systems substantially simultaneously, enabling a visual comparison of CLI operations across different operating systems with the same or different commands and options to the user 390. For example, regarding the same or different commands and options, one window might simulate the command line of the IBM AIX® operating system, while another window might simulate the command line of the Solaris operating system. Such multiple operating system displays can be initiated in response to a user request to switch to a new operating system, in which case the new window can be automatically generated by the ICSB rendering engine 364 on the client computing device 380 to depict the new operating system and the simulated command-line interface results. This is particularly useful for educational, training, and certification purposes.

[0098] Figure 4 This is an example flowchart illustrating example operation of the ICSB framework and system according to an exemplary embodiment. It should be understood that... Figure 4 The operations outlined herein are performed automatically by improved computer tools of exemplary embodiments and are not intended to be performed by humans as mental processes or through the organization of human activities, and are in fact not capable of being performed by humans. Rather, although in some circumstances, humans may initiate their execution. Figure 4 The operations described herein, and in some cases, can be utilized as Figure 4The result is generated based on the operations described in the text, but Figure 4 The operations themselves are performed automatically by improved computing tools.

[0099] like Figure 4 As shown, user 390 installs ICSB client 360 on their client computing device and can then log in to ICSB server 310, which can provide AI chatbots or other natural language-based AI computing systems, enhanced to include tools and functions for simulating an operating system command-line interface. Requests to simulate the OS and OS command lines are identified by ICSB monitor 362 of ICSB client 360. ICSB monitor 362 sends the user request for OS and command-line simulation to ICSB parser 340. ICSB parser 340 parses the user request and invokes ICSB extractor 342 to extract features indicating ICSB data structure characteristics from the user request, such as OS name, user identifier, command name, command options, etc. ICSB identifier 344 identifies these features among the extracted features and updates ICSB data structure 324 via ICSB manager 320.

[0100] Based on the extracted and identified features, it is determined whether the user requests the use of a new operating system to simulate a command-line interface. If so, the operating system simulation agent 346 is invoked to simulate the operating system environment. Subsequently, or if the operating system is not a new operating system, the command-line interface simulator 348 is invoked to simulate the command-line interface on the user-input commands requested by the user. This is referred to as the "runtime" or simulation phase of operation 420.

[0101] The command-line interface simulator 348 operates based on CLI models stored in CLI repository 334 and other parameters used to configure the CLI simulation (e.g., user profile data 328 and ICSB standard 326). User input and simulation results are used to populate fields of ICSB data structure 324 over time as the user interacts with ICSB server 310 via ICSB client 360. During the machine learning phase 430 of the operation, ICSB server 310 invokes ICSB learner 330 to ingest structured and unstructured documents and data from data source 332 to learn CLI models of commands / options for various operating systems and their command-line interfaces, as specified in user profile 328 and ICSB standard 326. ICSB service profile 322 and user profile 328 are configuration files, for example, in plain text or XML format. ICSB service profile 322 (controlled and edited by the administrator via ICSB manager 320) can include advanced configuration parameters and settings for all ICSB users. ICSB service profile 322 can include ICSB data structures and ICSB standards. Administrators can add, remove, or change ICSB data structures and standard attributes within the ICSB standard. For example, the default background colors for emulated Linux® and AIX® operating systems are black and white, respectively, and administrators can, for instance, set the default color of all error messages to red.

[0102] Similarly, user profile 328 includes personal characteristics and customization settings. For example, the first user (e.g., USER-1) can add / save new emulated operating systems, such as Microsoft Windows 11, along with CLI documents and sources related to Microsoft Windows 11 332 in the user profile. Additionally, the user can set the background color of the emulated operating system Linux to white for improved readability. Any user-specific personal characteristics and customization settings can be configured in user profile 328.

[0103] CLI models for various operating systems and command-line interfaces are stored in the CLI repository 334 for the CLI simulator 348 to retrieve to generate CLI simulation results, which are then provided back to the ICSB rendering engine 364 to render a graphical / textual representation of the simulated command-line interface of the requested operating system, in particular a simulation of user-input commands and options generated by the actual CLI of the actual operating system.

[0104] The mechanisms of the exemplary embodiments can be used in many different ways to facilitate education, training, certification, research, and product development. One advantage of the exemplary embodiments is that they allow for the rapid identification of differences between command-line interfaces of various operating systems, as well as differences between CLI results generated for different commands and options in one or more command-line interfaces, with minimal resources and time. Figure 5 This is an example diagram illustrating the simulation of commands in a simulated operating system CLI according to an exemplary embodiment. In the illustrated example, a user request or user input is shown as element 510, which includes a specification 512 of a specific operating system command line to be simulated, which is Linux in the illustrated example. The user request further specifies the list file command "ls -1", and further lists the "ls -1" command with various output language (or locale) options, such as English (en_US.UTF-8), Chinese (zh_CN.UTF-8), and Russian (ru_RU.UTF-8). As can be seen in element 520, for each of these options, there is a different output, where the word "total" is presented in the corresponding locale language. Such output 520 can be obtained quickly and easily using the mechanism of the exemplary embodiment, where the command input 510 is displayed using CLI simulation, which simulates different CLI responses to the input user command.

[0105] Therefore, from Figure 5 As can be seen, the exemplary embodiment can be operated to demonstrate that the same CLI with the same options in the same OS may produce different outputs due to execution under different language / region settings. In a real operating system, to obtain similar demonstration results in this example, the user must install the required language / region setting packages (en_US.UTF-8, zh_CN.UTF-8, and ru_RU.UTF-8 in this example), and the installation of such different region setting packages may require root privileges, making the installation and configuration of multi-language packages difficult, inconvenient, and time-consuming in a real system. However, in the exemplary embodiment, different regional setting environments can be simulated, which is very useful in educational, new feature design, and customer support applications.

[0106] Figure 6 This is an example diagram illustrating simulated CLI output or results generated based on input commands to the ICSB framework and system according to an exemplary embodiment. The simulated CLI output or results can be presented to the user through the ICSB rendering engine, which can render, for example... Figure 6Screens 640-660 are shown in the image. These screens simulate the actual command-line interface that would be seen if an instance of the operating system and its command-line interface were installed and configured. However, these screens 640-660 are actually simulated command-line interfaces that present simulated CLI responses generated by the ICSB server based on user requests from ICSB clients.

[0107] like Figure 6 As shown, user request or input 610 includes user request 612 simulating the command-line interface of the Red Hat Linux® operating system, followed by the specification of a file "test.txt" 614 on which commands are to be run, where the first 6 lines of the example "test.txt" file are "Apple-1" to "Apple-6", and the next 6 lines are "Peach-1" to "Peach-6". User request 610 further specifies the command 616 "grep -m 1 Apple test.txt", where "grep" is the command, "-m 1" is the command option, "Apple" is the string to search for, and "test.txt" is the file on which command 616 is to be executed. The grep command 616 is designed to return the first line in the test.txt file that contains the string "Apple".

[0108] The user sessions also include subsequent user requests 620 and 630. These user commands include commands to change the operating system from Red Hat Linux® to AIX. Additionally, these user requests specify similar grep commands. In the case of user request 620, the command will return an "illegal option" CLI mock response because the option "-m" is not supported by AIX®, as learned and represented in the CLI model by the mechanism of the exemplary embodiment. In the case of user request 630, the user enters a different form of the grep command with appropriate options, resulting in a mock CLI response. The mock CLI responses generated by the mechanism of the exemplary embodiment are shown in screens 640, 650, and 660, respectively. As shown, for the first user request 610, the CLI mock response in screen 640 is "Apple-1," as is the case for the third user request 630 shown in screen 660. The output on screen 650 indicates the illegal option and provides alternative options for the command.

[0109] Therefore, as Figure 6As shown, the exemplary embodiment can be operated to demonstrate that the same CLI with the same options can return different outputs on different operating systems. Without the exemplary embodiment, in order to display different results on different OSes, the user must install and configure different systems with different operating systems on different hardware. Therefore, obtaining appropriate hardware with the correct OS is not easy or convenient for the average user. However, using the exemplary embodiment, the user can easily set up a simulated operating system for comparing, testing, and verifying CLIs with different options under different operating systems. This is also very useful in education, new feature design, and customer support.

[0110] As mentioned above, the ICSB server maintains information about user sessions with the ICSB server in the ICSB data structure over time. Figure 7 This is an example diagram of an ICSB data structure according to an exemplary embodiment, which evolves over time during an ICSB session with a user (i.e., a session between an ICSB server and an ICSB client). Figure 7 In the depiction, time intervals “Time-1” through “Time-7” are shown on the left, while various ICSB data structure fields 710 for various ICSB features are shown as separate columns at the top of the figure. The cells of the ICSB data structure contain data captured by the ICSB server for various time intervals for different features. A “Null” value indicates that this feature has not been set during the ICSB session.

[0111] like Figure 7 As shown, initially, when an ICSB session is established, no features are populated (time - 1). Subsequently, at time - 2, the user can submit a user request, such as "In Linux" (760), where the user request specifies the user's user ID (710), the user-entered command "In Linux" (760), and generates corresponding CLI emulation output (780) based on the command (760), for example, identifying "OS=Linux". At the next time interval (time - 3), the user enters a command specifying the test.txt file, as shown (760). The OS name (720) is updated to reflect that the operating system is Linux, the configuration information (730) is updated to reflect the configuration for Linux® and the user (710), the CLI list based on the Linux® OS (740) is updated, and the CLI log (750) is updated to reflect the CLI emulation response from the previous time interval, i.e., "OS=Linux". The command output from the CLI emulation response is displayed in field 780, which includes the contents of the test.txt file.

[0112] In the subsequent time interval (time-4), the CLI log (750) is updated again with the CLI mock response (780) from the previous time interval, a new user command (760) is entered, such as "grep -m 1 Apple test.txt", and the command options for that command are recognized and stored in the command options field (770), such as "grep", "-m", "1", "Apple", "test.txt". The CLI mock response is stored in the command output field (780), such as "Apple-1".

[0113] The process continues with each subsequent time interval and each user request / command entered by the user, for example, "in AIX" at time interval time-5, "grep -m 1 Apple test.txt" at time interval time-6, and "grep Apple test.txt| head -1" at time interval time-7, as follows. Figure 7 As shown. Therefore, the ICSB data structure is dynamically and automatically updated as the session between the ICSB server and ICSB client continues. The ICSB data structure is used to facilitate the presentation of simulated CLI results to ICSB clients and to record ICSB sessions.

[0114] As mentioned above, the ICSB data structure and its contained attributes change dynamically over time based on user requests. Therefore, using... Figure 7 The example shown assumes that all parameters are NULL at the initial time. Subsequently, for times -2 to -7, the following dynamic modifications are made over time:

[0115] Time -2: User001 in the ICSB client types "in Linux". As part of the user request, the value of "UserCMD" is parsed, and the value of CMD is recognized by the ICSB server. The CMD output is OS=Linux

[0116] Time-3: Related variable assignment operations on the ICSB server side. "OS NAME" = Linux. The simulated OS is initialized and / or changed to OS = "Linux". The next user request is received for the file "test.txt", which contains multiple lines: Apple-1 Apple-2 Apple-3 Apple-4 Apple-5 Apple-6 Peach-1 Peach-2 Peach-3 Peach-4 Peach-5 Peach-6. CMD output is simulated as "cat test.txt Apple-1 Apple-2 Apple-3 Apple-4 Apple-5 Apple-6 Peach-1 Peach-2 Peach-3 Peach-4 Peach-5 Peach-6".

[0117] Time -4: The ICSB server receives a new user request "grep -m 1 Apple test.txt" and the assignment: "CMD Options" = ("grep", "-m", "1", "Apple" test.txt"). Based on what has been learned, the simulated CMD output = "Apple", which is returned to the ICSB client as the simulated output result.

[0118] Time -5: The ICSB server receives a new request "in AIX" and then changes the OS system from Linux® to "OSNAME" = "AIX".

[0119] Time -6: The ICSB server receives a new user request "grep -m 1 Apple test.txt" and assigns values: "CMD Options" = ("grep", "-m", "1", "Apple" test.txt"). Then, based on learned knowledge, it simulates the CMD output as "grep: illegal option -- m Usage: grep [-E|-F] [-c|-l|-q][-bhinsvx] -e pattern_list... [-f pattern_file...] [file...]", and returns it to the ICSB client as the simulated output. Then, it updates the error state to -1 (meaning an error was found).

[0120] Time -7: The ICSB server receives a new user request "grep Apple test.txt | head -1", and then assigns values: "CMD Options" = ("grep", "Apple", "test.txt", "|", "head", "-1"). Then, based on learned knowledge, it simulates CMD output as "Apple-1" and returns it as the simulated output to the ICSB client.

[0121] The description of this invention is for illustrative and descriptive purposes only and is not intended to be exhaustive or to limit the invention to the forms disclosed. Many modifications and variations will be apparent to those skilled in the art without departing from the scope and spirit of the described embodiments. These embodiments were chosen and described in order to best explain the principles of the invention, its practical application, and to enable those skilled in the art to understand the various embodiments and their various modifications suitable for the intended use. The terminology used herein has been chosen to best explain the principles of the embodiments, their practical application, or technical improvements relative to the technology on the market, or to enable those skilled in the art to understand the embodiments disclosed herein.

Claims

1. A method for simulating an operating system in a data processing system, the method comprising: For each of one or more operating systems, a corresponding artificial intelligence (AI) computer model is trained, which learns patterns of input features of the inputs to the operating system and corresponding responses from the operating system through machine learning training. Receive a request from the requester's computing device to simulate the requested operating system; Receive simulated input from the requester's computing device to simulate the processing of the requested operating system on it; Retrieve the AI ​​computer model corresponding to the requested operating system; The retrieved AI computer model is executed on the simulated input to simulate the processing of the simulated input by the requested operating system, thereby generating a simulated response; as well as The simulated response is returned to the requesting computing device as a simulated output of the requested operating system in response to the input.

2. The method according to claim 1, wherein the corresponding AI computer model is a command-line interface (CLI) computer model that maps the pattern of input characteristics of commands input to the CLI of the operating system to the corresponding CLI response.

3. The method of claim 1 or 2, wherein the request is a CLI request simulating the requested operating system, and wherein the input to simulate processing by the requested operating system is a command to the CLI.

4. The method according to any one of the preceding claims, wherein the simulated input is a command-line interface (CLI) command for the requested operating system, and wherein the simulated output is a simulated CLI response generated by simulating the requested operating system based on the retrieved AI computer model.

5. The method of claim 4, wherein returning the simulated response to the requesting computing device as a simulated output of the requested operating system in response to the input comprises: The simulated CLI response is returned in a simulated user interface that mimics the command-line interface of the requested operating system.

6. The method according to any one of the preceding claims, wherein the mode of the input feature includes a mode of operating system commands input to the command-line interface of the operating system and corresponding options for those operating system commands.

7. The method according to any one of the preceding claims, wherein: The one or more operating systems include multiple operating systems. Training the AI ​​computer model includes training a separate AI computer model for each of the multiple operating systems, and Each of the AI ​​computer models is trained to simulate the same set of command-line interface commands, but each is specific to a corresponding operating system among the multiple operating systems.

8. The method according to any one of the preceding claims, wherein the AI ​​computer model is trained by machine learning processing based on a training dataset, the training dataset comprising a set of command-line interface commands, options for the command-line interface commands, and expected command-line interface output for the commands and options based on an ingested source document corpus, the source document corpus comprising operating system design documents, support centers, and manual pages.

9. The method according to any one of the preceding claims, wherein the request is a natural language request submitted via a chatbot interface and specifies the requested operating system and the simulated input to be simulated by the requested operating system.

10. The method according to any one of the preceding claims, further comprising: Receive a user profile that specifies a subset of operating systems to be simulated, wherein for each of the operating systems specified in the user profile, the training of the corresponding AI computer model is performed.

11. The method of claim 10, wherein, for a subset of the operating system, the user profile further specifies the range of commands to be learned through the training of the corresponding AI computer model, and a default set of environment variables to be used when simulating a subset of the operating system.

12. The method according to any one of the preceding claims, further comprising: In response to the simulated response, user feedback information is received, indicating whether the simulated response is correct or incorrect; as well as The training of the retrieved AI computer model is updated based on the user feedback information.

13. A computer program product comprising a computer-readable storage medium having a computer-readable program stored therein, wherein when executed in a data processing system, the computer-readable program causes the data processing system to emulate an operating system at least in the following ways: For each of one or more operating systems, a corresponding artificial intelligence (AI) computer model is trained, which learns patterns of input features of the inputs to the operating system and corresponding responses from the operating system through machine learning training. Receive a request from the requester's computing device to simulate the requested operating system; Receive simulated input from the requester's computing device to simulate the processing of the requested operating system on it; Retrieve the AI ​​computer model corresponding to the requested operating system; The retrieved AI computer model is executed on the simulated input to simulate the processing of the simulated input by the requested operating system, thereby generating a simulated response; as well as The simulated response is returned to the requesting computing device as a simulated output of the requested operating system in response to the input.

14. The computer program product of claim 13, wherein the corresponding AI computer model is a command-line interface (CLI) computer model that maps the pattern of input characteristics of commands input to the CLI of the operating system to the corresponding CLI response.

15. The computer program product of claim 13 or 14, wherein the request is a CLI request simulating the requested operating system, and wherein the input to simulate processing by the requested operating system is a command to the CLI.

16. The computer program product according to any one of claims 13 to 15, wherein the simulated input is a command-line interface (CLI) command for the requested operating system, and wherein the simulated output is a simulated CLI response generated by simulating the requested operating system based on the retrieved AI computer model.

17. The computer program product of claim 16, wherein returning the simulated response to the requesting computing device as a simulated output of the requested operating system in response to the input comprises: The simulated CLI response is returned in a simulated user interface that mimics the command-line interface of the requested operating system.

18. The computer program product according to any one of claims 13 to 17, wherein the mode of the input feature includes a mode of operating system commands input to the command-line interface of the operating system and corresponding options for those operating system commands.

19. The computer program product according to any one of claims 13 to 18, wherein: The one or more operating systems include multiple operating systems. Training the AI ​​computer model includes training a separate AI computer model for each of the multiple operating systems, and Each of the AI ​​computer models is trained to simulate the same set of command-line interface commands, but each is specific to a corresponding operating system among the multiple operating systems.

20. An apparatus comprising: At least one processor; as well as At least one memory coupled to the at least one processor, wherein the at least one memory includes instructions that, when executed by the at least one processor, cause the at least one processor to emulate an operating system at least in the following ways: For each of one or more operating systems, a corresponding artificial intelligence (AI) computer model is trained, which learns patterns of input features of the inputs to the operating system and corresponding responses from the operating system through machine learning training. Receive a request from the requester's computing device to simulate the requested operating system; Receive simulated input from the requester's computing device to simulate the processing of the requested operating system on it; Retrieve the AI ​​computer model corresponding to the requested operating system; The retrieved AI computer model is executed on the simulated input to simulate the processing of the simulated input by the requested operating system, thereby generating a simulated response; as well as The simulated response is returned to the requesting computing device as a simulated output of the requested operating system in response to the input.

Images