Abstract: Embodiments are directed to managing machine learning models. Domain items may be determined based on domain data and schema information. Labels that correspond to a predicted outcome may be generated based on the domain data. A model may be trained based on a portion of a plurality of feature records and the labels such that each feature record may be associated with an observance of a domain item. The trained model may be disqualified based on evaluation metrics that may be below a threshold value causing further actions, including: submitting other portions of the feature records to the disqualified model; determining erroneous feature fields in the feature records based on metrics associated with the submission of the other portions of feature records; updating the feature records to exclude the erroneous feature fields; retraining the disqualified model based on the updated feature records.

Abstract: An intent negotiation method and apparatus are provided. The method includes: A first network element sends a first sub-intent of a first intent to a second network element, and sends a second sub-intent of the first intent and indication information to the second network element, where the indication information is used to indicate that the first sub-intent and the second sub-intent have a same action and a same object.

Abstract: There is provided an apparatus comprising means for: receiving, at a coordinating network function from a network function consumer, at least one data request, wherein the at least one data request indicates at least one version of an application programming interface supported by the network function consumer; and causing, by the coordinating network function, data to be provided to the network function consumer from at least one data source based on the at least one data request and one or more versions of an application programming interface supported by the at least one data source.

Abstract: The disclosure describes various embodiments for determining emails that each need a response based on data from a customer relationship (CRM) system. In one embodiment, a method of determining such emails includes the operations of retrieving open tasks assigned to a user from a task database; determining one or more source email domains for one or more source contacts, and one or more target email domains for one or more target contacts; and determining one or more threads emails exchanged between the source contacts and the target contacts based on the source email domains and the target email domains. The method further includes the operations of creating an email list from the threads of emails, including a latest email from a group that was sent by a target contact; and generating a subset of the list of emails by analyzing contents of each of the list of emails using a machine learning model.

Abstract: Various methods, apparatuses/systems, and media for dynamic code analysis using aspect oriented programming (AOP) are disclosed. A processor (i) creates a list of all method names associated with an application before launching the application and writes into a file; (ii) at runtime, reads the method names from the file into a hash set and using AOP load time weaving, each time a method is invoked, pointcut around the execution of the method to remove method name from the hash set in memory; (iii) periodically overwrites the file with a dump of current entries in the hash set for fault tolerance; (iv) for every subsequent restart of the application, the processor repeats from processes (ii) and (iii). After running processes (i)-(iv) for a predetermined time period (a month, a quarter etc.), the processor creates a final with methods that have not been invoked for potential deletion.

Abstract: A trace-data-processing device for reconstructing an execution flow of a program performed by a source device under test or under observation, herein DUT, using at least one source-specific trace-data stream is disclosed. The trace-data-processing device comprises a trace-data-processing unit, which is configured to identify in the trace-data stream at least one instruction-synchronization message and branch messages. Moreover, the trace-data-processing device is configured to generate runtime-information data indicative of an at least partial reconstruction of the execution flow, using the identified trace messages, a pre-defined branch identifier allocated to each branch instruction address in the program that is associated with a direct branch instruction and pre-stored reconstruction information stored in a reconstruction memory.

Abstract: In a particular embodiment, a dataset that is synchronously replicated across a plurality of storage systems is stored on a particular storage system. The storage system identifies input/output (I/O) requests directed to the dataset. The one or more I/O requests are initiated by an application hosted on a platform of the first storage system. The storage system services the one or more I/O requests directed to the dataset.

Abstract: A configuration workstation generates configuration tables representative of applications that each comprise one or more object data structures. Each of the object data structures are linked to one or more staging databases that, in turn, obtain data from one or more standalone data sources. Each of the object data structures comprises at least one property that defines available data for the object data structure. The configuration tables are provided to a controller that obtains data from the staging database(s). The controller also causes the obtained data to be converted to the semantic data format and stored in a semantic database. A web server obtains requested semantic data from the semantic database for at least some of the object data structures for an application. The web server then generates a user interface based on the requested semantic data and provides it to a user device for display.

Abstract: Provided is a process including: writing modelling-object classes using object-oriented modelling of the modelling methods, the modelling-object classes being members of a set of class libraries; writing quality-management classes using object-oriented modelling of quality management, the quality-management classes being members of the set of class libraries; scanning modelling-object classes in the set of class libraries to determine modelling-object class definition information; scanning quality-management classes in the set of class libraries to determine quality-management class definition information; using the modelling-object class definition information and the quality-management class definition information to produce object manipulation functions that allow a quality management system to access methods and attributes of modelling-object classes to manipulate objects of the modelling-object classes; and using the modelling-object class definition information and the quality-management class definitio

Abstract: A system and method of creating the natural language understanding component of a speech/text dialog system. The method involves a first step of defining user intent in the form of an intent flow graph. Next, (context, intent) pairs are created from each of the plurality of intent flow graphs and stored in a training database. A paraphrase task is then generated from each (context, intent) pair and also stored in the training database. A zero-shot intent recognition model is trained using the plurality of (context, intent) pairs in the training database to recognize user intents from the plurality of paraphrase tasks in the training database. Once trained, the zero-shot intent recognition model is applied to user queries to generate semantic outputs.

Abstract: Techniques for database query information protection using skeletons are described. An agent installed on a host computing device with a database instance obtains queries executed by the database instance and skeletonizes the queries to remove sensitive data from them. The agent identifies references within the queries, obtains structural definitions for the references, and inserts placeholders into the queries in place of the references and relates the placeholders to the definitions. The query skeletons and/or similarly-constructed execution plan skeletons may be analyzed to identify modifications to queries and/or the database instance to improve query processing.

Abstract: Detecting and reconfiguring of boot parameters of a NVMe subsystem, including identifying a mapping between local boot parameters of a NVMe subsystem and a GUID that corresponds to the NVMe subsystem; determining that the NVMe subsystem has been reset; in response to determining that the NVMe subsystem has been reset: transmitting a discovery request to the NVMe subsystem for remote boot parameters of the NVMe subsystem; comparing the local boot parameters for the GUID with the remote boot parameters for the NVMe subsystem; determining, based on the comparing, that the remote boot parameters for the NVMe subsystem do not match with the local boot parameters for the GUID, and in response, updating values of the local boot parameters for the GUID based on the remote boot parameters of the NVMe subsystem.

Abstract: A computer-implemented method for multi-modal interaction with structured web page data includes automatically injecting event monitoring code into a web page. One or more event streams generated by the injected event monitoring code are received. A request to perform an operation on data displayed on the web page is received from a user. A command is generated that has one or more parameters based at least in part on one or more mappings between the received request and the received one or more event streams. The command to fulfil the received request is executed by interacting with the web page.

Abstract: A computer-implemented method of responding to a conversational event. The method comprises enacting, by a conversational computing interface, an initial computer-executable plan based on a conversational event received by the conversational computing interface, wherein the initial computer-executable plan is configured to output an initial value based on the conversational event. The method further comprises selecting, by the conversational computing interface, an extended computer-executable plan based on determining that the initial value is insufficient for generating an extended description responsive to the conversational event. The method further comprises enacting, by the conversational computing interface, the extended computer-executable plan to output additional information beyond what the initial computer-executable plan is configured to output, the additional information sufficient for generating the extended description responsive to the conversational event.

Abstract: An image forming apparatus capable of preventing compatibility with an extension application from being impaired. The image forming apparatus installs an operation program of an extension application therein, and includes a VM (Virtual Machine) that executes a bytecoded program generated based on the operation program. The bytecoded program is generated by converting the operation program to bytecode. The operation program and the bytecoded program are written into a package, and the package is stored in a storage of the image forming apparatus.

Abstract: The present specification provides a method for executing a smart contract and a blockchain node. An implementation of a method for executing a smart contract includes: receiving, by a blockchain node, a request for creating a smart contract, the request including a bytecode of the smart contract; starting, by the blockchain node after completing deployment of the smart contract, to compile the bytecode of the smart contract into a machine code by using just-in-time and storing the machine code; and in execution of the deployed smart contract, executing, by the blockchain node, the machine code corresponding to a bytecode of the smart contract in response to the machine code being locally stored. According to the above implementations of the present application, the blockchain node can greatly increase a speed of executing a smart contract.

Abstract: Systems and methods for securing embedded devices via both online and offline defensive strategies. One or more security software components may be injected into firmware binary to create a modified firmware binary, which is functionally- and size-equivalent to the original firmware binary. The security software components may retrieve live forensic information related to embedded devices for use in live hardening of the modified firmware binary while the embedded device is online, dynamically patching the firmware. In addition, the live forensic information may be aggregated with other analytical data identifying firmware vulnerabilities. A vulnerability identification and mitigation system can then identify and inject modifications to the original firmware binary to develop secure firmware binary, which may be imaged and loaded onto one or more embedded devices within a network.

Abstract: Conventional methods for application development are rigid, complex, costly and ineffective in implementing new and changing technologies. The embodiments herein provide a model driven system and method for development of micro service applications. A set of user interface components and one or more domain components for a plurality of micro services designs of a plurality of applications pertaining to one or more technologies are modeled and validated. Further, a plurality of codes are generated according to the one or more modeled domain components of the plurality of micro services designs of the plurality of applications satisfying one or more requirements. The plurality of generated codes are further customized and validated to ensure design and code consistency. The plurality of customized codes are further containerized to provide a plurality of containerized applications which are deployed into a target deployment environment for execution using a plurality of configuration files.

Abstract: Embodiments relate to a system, program product, and method for implementing loop lock reservations, and, more specifically, for holding a lock reservation across some or all of the iterations of a loop, and under certain conditions, temporarily effect a running thread to yield the reservation and allow other threads to enter the lock.

Abstract: A system includes a content extraction engine comprising at least one processor and configured to receive a content page for a target product including product data for the target product and noise content unrelated to the target product, identify noise content pertaining to data unrelated to the target product, remove noise content from the content page, thereby generating a remainder content page containing target product data usable to enable product comparison between multiple sources.

Abstract: Described herein are embodiments for managing comments in a program code file. A system may select program code and compile it to an intermediary code. The system may compare the intermediary code to a library of intermediary code snippets associated with comments. Based on the comparison, a system may recognize the code to be obsolete. In some embodiments, a system may generate one or more recommendations to update a code. Based on received feedback regarding a recommendation, a system may accordingly update a code.

Abstract: A configuration workstation generates configuration tables representative of applications that each comprise one or more object data structures. Each of the object data structures are linked to one or more staging databases that, in turn, obtain data from one or more standalone data sources. Each of the object data structures comprises at least one property that defines available data for the object data structure. The configuration tables are provided to a controller that obtains data from the staging database(s). The controller also causes the obtained data to be converted to the semantic data format and stored in a semantic database. A web server obtains requested semantic data from the semantic database for at least some of the object data structures for an application. The web server then generates a user interface based on the requested semantic data and provides it to a user device for display.

Abstract: A function verification method for a boundary scan test controller is disclosed. In the method, the configuration positions of input/output connectors on a test board correspond to configuration positions of to-be-verified connectors on a boundary scan test controller, so that when the test board is stacked and positioned on the boundary scan test controller, the input/output connectors can be electrically connected to the to-be-verified connectors corresponding thereto, respectively. After being electrically connected to the boundary scan test controller via a USB port, the test control host creates a test script according to information of the test board and all operations of the to-be-verified connectors, and then execute a test program in the to-be-verified connectors according to the test script, and generates a test report, and determines whether the boundary scan test controller meets shipment or production requirement according to the test report.

Abstract: Methods and systems may provide for technology to determine dynamic path information and encoded type information associated with an application programming interface (API) and automatically generate a language-independent API definition based on the dynamic path information. In one example, the language-independent API definition is generated without reliance on source code annotations.

Abstract: A parsing system includes an imaging device and one or more processors. The imaging device may capture visual instructions displayed on a monitor. The one or more processors may be configured to receive, from the imaging device, the captured visual instructions, generate functions for a robot to perform based on the captured visual instructions, and transmit, to a robot, the functions to perform.

Abstract: A process set selection unit generates, based on a process set comprising a processing block performing arithmetic on a group of inputs and a group of outputs produced by the processing block, a group of new inputs having a combination number less than that of the group of inputs and a new processing block for the group of new inputs. A reuse execution unit prepares, based on the new processing block for performing arithmetic on the group of new inputs and a group of outputs produced by the new processing block, an associated result which associates the group of new inputs with the group of outputs, produces the group of outputs obtained from the association result if the group of new inputs have values equal to those of the group of inputs, and, if not, executes the new processing blocks to register an executed result to the associated result.

Abstract: Interaction between operating system components and device drivers via device driver function call addresses is monitored. Each device driver is configured to interface with at least one hardware component of a computing system. One or more verification functions of an extended device driver verification component are registered for at least one of the device driver function call addresses, each defining a predetermined verification condition. A device driver function call to one of the device driver function call addresses is intercepted and evaluated against the predetermined verification condition of the verification function registered for the device driver function call address of the intercepted device driver function.

Abstract: A system that implements a scalable data storage service may maintain tables in a non-relational data store on behalf of clients. The system may provide a Web services interface through which service requests are received, and an API usable to request that a table be created, deleted, or described; that an item be stored, retrieved, deleted, or its attributes modified; or that a table be queried (or scanned) with filtered items and/or their attributes returned. An asynchronous workflow may be invoked to create or delete a table. Items stored in tables may be partitioned and indexed using a simple or composite primary key. The system may not impose pre-defined limits on table size, and may employ a flexible schema. The service may provide a best-effort or committed throughput model. The system may automatically scale and/or re-partition tables in response to detecting workload changes, node failures, or other conditions or anomalies.

Abstract: An information processing apparatus includes a first communication unit configured to communicate with a first communication apparatus; a second communication unit configured to wirelessly communicate with each of one or more second wireless communication apparatuses; an acquisition unit configured to acquire from the first communication apparatus via the first communication unit an apparatus ID that is held by the first communication apparatus and that is used for identifying one of the one or more second wireless communication apparatuses to or from which the second communication unit transmits or receives data; and a control unit configured to control the second communication unit to transmit or receive the data to or from the one of the one or more second wireless communication apparatuses that is identified by the apparatus ID acquired by the acquisition unit.

Abstract: Interaction between operating system components and device drivers via device driver function call addresses is monitored. Each device driver is configured to interface with at least one hardware component of a computing system. One or more verification functions of an extended device driver verification component are registered for at least one of the device driver function call addresses, each defining a predetermined verification condition. A device driver function call to one of the device driver function call addresses is intercepted and evaluated against the predetermined verification condition of the verification function registered for the device driver function call address of the intercepted device driver function.

Abstract: Techniques to configure a web-based application for bot configuration are described. In one embodiment, an apparatus may comprise a web application hosting component operative to receive a bot-configuration request from a web client, the bot-configuration request corresponding to a developer account for a bot system; and provide a web-based application to the web client; and a web-application preparation component operative to prepare the web-based application for the web client, the web-based application comprising a simulated user environment interface, a code development interface, and a natural-language-processing log interface, wherein the simulated user environment interface corresponds to a user interface for the bot system. Other embodiments are described and claimed.

Abstract: The subject disclosure is directed towards a technology for efficiently emulating program code that is protected by one or more various code virtualization techniques to detect the presence of malware. An emulation engine emulates a program containing a mix of native code, custom (e.g., virtualized obfuscated) code, and at least one emulator and/or interpreter that understands the custom code, by building a custom emulation component that is built by detecting and analyzing the internal emulator or interpreter. The custom emulation component may access a translation table built from the analysis, and also may simplify a plurality of instructions in the program into a lesser number of instructions in an intermediate language used for emulation.

Abstract: Unused instructions and no longer used instructions in a target application binary are determined. The target application binary is rewritten before and after runtime execution of the target application binary to remove the unused and no longer used instructions to reduce binary attack surface area for the runtime execution of the target application binary. Methods, computer systems, and computer program products are disclosed.

Abstract: Methods, systems, and apparatus, including computer programs encoded on a computer storage medium, for automated management of campaigns using scripted rules.

Abstract: A method for using profiling to obtain application-specific, preferred parameter values for an application is disclosed. First, a parameter for which to obtain an application-specific value is identified. Code is then augmented for application-specific profiling of the parameter. The parameter is profiled and profile data is collected. The profile data is then analyzed to determine the application's preferred parameter value for the profile parameter.

Abstract: Methods, systems, and apparatus, including computer programs encoded on computer storage media, for generating a commit graph for a software project maintained in a version control system having a directory-based branching structure. One of the methods includes receiving data representing a commit history of a software project maintained in a version control system having a directory-based branching system in which each branch of the commit history has a respective branch directory and each revision is identified by a branch path and a revision number. The commit history is traced backward in time from a starting commit of a branch to identify an initial commit in which a branch directory for the branch was created. The commit history is then processed forward in time from the initial commit to generate a tree-structured commit graph.

Abstract: A classloader executing in an execution environment, such as a JAVA virtual machine or a software container, may be configured to generate class usage data describing the historical usage of classes by applications in the execution environment. Based upon the class usage data, one or more classes may be pre-loaded into a cache prior to receiving a request from an application to load the classes. If an application subsequently requests a class, the request may be satisfied using the class stored in the cache rather than by loading the class at the time the request is received. A probabilistic data structure, such as a Bloom filter, might also be utilized to determine whether a classloader can possibly load a requested class. Only if the classloader can possibly load the requested class will a search be made for the requested class in a classpath associated with the classloader.

Abstract: A procedural pattern in a received query execution plan can be matched to a stored pattern for which an equivalent declarative operator has been pre-defined. The query execution plan can describe a query for accessing data. A hybrid execution plan can be generated by replacing the procedural pattern with the equivalent declarative operator. A hybrid execution plan processing cost can be assigned to execution of the hybrid execution plan and a query execution plan processing cost can be assigned to execution of the query execution plan. The assigning can include evaluating a cost model for the hybrid execution plan and the query execution plan. The query can be executed using the hybrid execution plan if the hybrid execution plan processing cost is less than the query execution plan processing cost or the query execution plan if the hybrid execution plan processing cost is greater than the query execution plan processing cost. Related systems, methods, and articles of manufacture are disclosed.

Abstract: A computer-implemented method for automatically reviewing structured query language (SQL) statements comprises the steps of receiving SQL code from a user seeking to access a database, parsing the SQL code to retrieve SQL keywords, mathematical operators, and logical operators, applying a complexity score calculation algorithm to the parsed code, calculating a complexity score, and executing the SQL code on a computing system which stores the database if the complexity score is less than or equal to a threshold. On the other hand, if the complexity score is greater than the threshold, the SQL code may be flagged to be rewritten.

Abstract: Systems and methods to detect malicious executable files having a script language interpreter by combining a script emulator and a machine code emulator. A system includes an analyzer configured to convert a script into pseudocode and monitor an emulation process of the pseudocode, a script emulator configured to sequentially emulate the pseudocode and write emulation results to an emulator operation log, and a machine code emulator configured to emulate the pseudocode if a transition from pseudocode to machine code is detected by the analyzer, such that the analyzer can analyze the emulator operation log to determine if the executable file is malicious.

Abstract: In one embodiment, the present invention includes a method for receiving an interrupt from an accelerator, sending a resume signal directly to a small core responsive to the interrupt and providing a subset of an execution state of the large core to the first small core, and determining whether the small core can handle a request associated with the interrupt, and performing an operation corresponding to the request in the small core if the determination is in the affirmative, and otherwise providing the large core execution state and the resume signal to the large core. Other embodiments are described and claimed.

Abstract: A computer-implemented method includes receiving, from a natural language interface system, a natural language task specification, and converting the natural language task specification into a domain independent data flow graph. The data flow graph includes substeps. The method further includes: presenting the data flow graph via the natural language interface system as a natural language program; interactively refining the natural language program; and correspondingly modifying the data flow graph. The computer-implemented method further includes, for each substep: selecting one or more candidate APIs from an API library, based on the substep; interactively narrowing the one or more candidate APIs to at least one selected API; implementing the substep by specifying one or more calls to the at least one selected API to yield a substep implementation; and appending the substep implementation to a result program. A corresponding computer program product and computer system are also disclosed.

Abstract: The system and method for structuring self-provisioning workloads deployed in virtualized data centers described herein may provide a scalable architecture that can inject intelligence and embed policies into managed workloads to provision and tune resources allocated to the managed workloads, thereby enhancing workload portability across various cloud and virtualized data centers. In particular, the self-provisioning workloads may have a packaged software stack that includes resource utilization instrumentation to collect utilization metrics from physical resources that a virtualization host allocates to the workload, a resource management policy engine to communicate with the virtualization host to effect tuning the physical resources allocated to the workload, and a mapping that the resource management policy engine references to request tuning the physical resources allocated to the workload from a management domain associated with the virtualization host.

Abstract: A method of compiling a source code described by a first programming language, the method being executed by a computer and includes: specifying a function described by a second programming language different from the first programming language from the source code, the function being allowed to use one or more arguments; and first creating an instruction to store given data that causes occurrence of an error when a register is accessed due to execution of the function in an area in the register for an argument that is not set for the function in the source code among the one or more arguments.

Abstract: Disclosed in the present invention are an inter-process communication method based on an application layer of Android and a basic application communication system. In accordance with a client/server communication mode, frame encapsulation applications for the mutual communication between system-level applications and user applications are created and virtualized as a client side; a daemon process IPC Service is created and virtualized as a server side; registration and binding of the IPC Service are completed through the applications, so as to achieve mutual communication among every application. Through the adoption of the technical solution of the present invention, a special communication mechanism can be rapidly and safely built during the inter-process communication of every application.

Abstract: In one embodiment, the present invention includes a method for receiving an interrupt from an accelerator, sending a resume signal directly to a small core responsive to the interrupt and providing a subset of an execution state of the large core to the first small core, and determining whether the small core can handle a request associated with the interrupt, and performing an operation corresponding to the request in the small core if the determination is in the affirmative, and otherwise providing the large core execution state and the resume signal to the large core. Other embodiments are described and claimed.

Abstract: The invention relates to a method for generating executable code from application source code. The method steps include determining a programmatic expression using the application source code and determining a first value for the programmatic expression. The method steps further include compiling the programmatic expression into a first optimized code portion using the first value, an assumption, and an expression scope. The method steps further include executing the application source code. The method steps further include determining that the programmatic expression is modified outside of the expression scope, invalidating the assumption, and de-optimizing the first optimized code portion.

Abstract: Selective storing of previously decoded instructions of frequently-called instruction sequences in an instruction sequence buffer to be executed by a processor is disclosed. In one aspect, a selective instruction sequence buffer controller is configured to selectively store previously decoded instructions for an instruction sequence by determining if a received instruction address corresponds to an instruction sequence captured in an instruction sequence buffer. If the received instruction address corresponds to a captured instruction sequence, the selective instruction sequence buffer controller provides corresponding micro-operations stored in the instruction sequence buffer for execution. If the received instruction address does not correspond to the captured instruction sequence, the selective instruction sequence buffer controller reduces a frequency indicator of the instruction sequence.

Abstract: Methods and a system are provided. A method includes implementing a function, which a compiler for a first language does not have, using a compiler for a second language. The implementing step includes generating, by the compiler for the first language, a first abstract syntax tree. The implementing step further includes converting, by a converter, the first abstract syntax tree to a second abstract syntax tree of the compiler for the second language using a conversion table from data representation types in the first language to data representation types in the second language. When a compilation error occurs, the implementing step also includes generating a special node for error processing in the second abstract syntax tree and storing an error token in the special node. When unparsing, the implementing step additionally includes outputting the error token, in the form of source code written in the first language.

Abstract: Disclosed are systems, methods, and non-transitory computer-readable storage media for automatically updating a hybrid web application. In some implementations, a computing device can be configured with a hybrid application that includes a native layer and a web view. The native layer can provide access to native features of the computing device while the web view can provide web client features, such as graphical user interfaces and server communication functionality. When the hybrid application is invoked, the native layer can load a resource bundle from local storage. The resource bundle can include the web code needed to present the web view graphical user interface, manage application data, and/or facilitate communication with the web server. To update the hybrid application, the application can download an updated resource bundle from the web server and reload the web code from the resource bundle.