Abstract: Certain example embodiments herein relate to techniques for automatically correcting and completing data in sparse datasets. Records in the dataset are divided into groups with properties having similar values. For each group, one or more properties of the records therein that is/are to be ignored is/are identified, based on record distances relative to the records in the group, and distances among values for each of the properties of the records in the respective group. The records in the groups are further divided into sub-groups without regard to the one or more properties that is/are to be ignored. The sub-groups include a smaller and more cohesive set of records. For each sub-group: based on the records therein, predicted values to be applied to values identified as being empty but needing to be filled in are determined; and those predicted values are applied. The corrected/completed dataset is provided as output.

Abstract: Techniques enable an application for execution in a heterogeneous computing environment including an on-premise server and a Software-as-a-Service (SaaS) provider. A scaffold defining assets usable by the application and configuration details therefor is developed. At least one scaffold map is generated. Each specifies target servers where individual assets are located and/or to be located. Different scaffold maps are generated for different user-specifiable environments to which the application is deployable. An application manager helps generate agent manifests based on the scaffold and one or more scaffold maps. The agent manifests are usable to configure respective target servers. A package manager helps provision the target servers based on the agent manifests. The provisioning includes distributing to corresponding target servers, and processing thereon, the agent manifests. The processing includes rolling back the distribution responsive to an occurrence of a defined exception case.

Abstract: Certain example embodiments relate to techniques for use with mainframe computing systems that include both general-purpose processors (e.g., CPs) and special-purpose processors that can be used to perform only certain limited operations (e.g., zIIPs). Certain example embodiments automatically help these special-purpose processors perform user exits and other routines thereon, rather than requiring those operations to be performed on general-purpose processors. This approach advantageously can improve system performance when executing programs including these user exits and other routines, and in a preferred embodiment, it can be accomplished in connection with a suitably-configured user exit daemon. In a preferred embodiment, the daemon and its clients can use a user exit property table or the like to communicate with one another about the state of each user exit or other routine that has been analyzed, classified, and possibly modified.

Abstract: Certain example embodiments relate to web applications. In certain example embodiments, an instance of a web application is executed using a client device. In response to the instance being started up, metadata is retrieved using a service embedded in the application and invoked at a bootstrap hook. The metadata is associated with earmarked programmatic elements in the application. At the client device and using an evaluation service injected into operation of the instance, one or more configured rules are evaluated against input. The rules are definable in relation to the earmarked programmatic elements using the retrieved metadata. They specify behavior of the web application and are dynamically (re)configurable while the instance of the web application is running. The (re)configured rules are dynamically effective without requiring web application redeployment, even if (re)configured while the instance of the web application is running. The instance is controllable responsive to the evaluation.

Abstract: Certain example embodiments test an application for security vulnerabilities. Binary and/or source code representations are subjected to static testing. Static testing identifies potential security weaknesses in the application. For each potential security weakness, a corresponding dynamic test set, containing one or more test cases, is generated based on (i) the corresponding potential security weakness, and (ii) lookups to weakness, application context, and attack pattern databases. The weakness database includes different weakness types and descriptions thereof. The attack pattern database includes information about how to generate attacks for the different weakness types. An instance of the application running in a test runtime environment is dynamically tested using the dynamic test cases. The dynamic test results verify whether each potential security weakness is a real vulnerability. The dynamic test results include fewer false-positives than the raw static test results.

Abstract: Certain example embodiments relate to data migration. During setup, migration reference and change log tables are created. The former includes instructions for implementing changes to accommodate the migration. A custom migration procedure is generated to process these instructions. Triggers are created to automatically record, in the change log table, information about data-related actions performed on tables structured using the source schema. During backup, the triggers are activated, and the migration procedure is run to conform a restored version of the data in the tables structured using the source schema to the target schema.

Abstract: A data analysis system is provided. Processing resources are configured to at least: identify features within a dataset, identify potential features of interest therefrom, and enable selection of one of the identified potential features of interest. Responsive to an identified potential feature of interest being selected: (a) algorithms are run on the dataset to identify at least one related feature that the selected feature of interest is most likely and/or most heavily influenced by; (b) a display is generated to include a visual representation of each related feature, each including associated data value representations; and (c) a visual representation can be selected. A data value representation is selectable together with the selected visual representation. Responsive selection of the visual representation, (a)-(c) are repeated. Responsive to a data value representation being selected in (c), the dataset is filtered based on it, and the repetition is performed with the filtered dataset.

Abstract: An electronic resource tracking and storage computer system communicates with computing systems operated by different participants. Computing systems store copies of a blockchain and have associated computing devices with sensors. A programmed rule set includes conditions to be met when cooperating to complete, in connection with a resource tracked via the blockchain, a modeled process including modeled tasks. A transceiver receives, from the computing devices, signed electronic data messages including identifiers and values from their respective sensors. Blockchain transactions including identifiers and value(s) in the respective messages are generated. Generated blockchain transactions are published for inclusion in blockchain's copies. Value(s) in the respective electronic data messages are validated against the set of programmed rules. Based on the validations' results, events are emitted to an event bus monitored by a management system.

Abstract: Certain example embodiments modify portions of a program, represented by object code stored in an executable, to be executed in a computing environment including general-purpose and special-purpose processors. Culprit calls in the object code deemed ineligible for execution by the special-purpose processor are identified. For each identified call: inserted into an allocated area are instructions that cause the program to temporarily cease executing calls using the special-purpose processor and instead execute an equivalent to the respective culprit call using the general-purpose processor, and return to executing calls using the special-purpose processor following execution of the respective culprit call using the general-purpose processor; and the respective identified culprit call is replaced with a branch instruction for the allocated area to cause the program to execute the inserted instructions rather than the replaced respective culprit call.

Abstract: A system for automatically updating a process model is provided. The system uses semantic similarities between externally sourced textual data and textual descriptions contained in the process model to classify words in the externally sourced textual data into one of multiple possible actionable categories. The textual data is then parsed for dependent words that are used to automatically update to an existing process model.

Abstract: Certain example embodiments automatically generate complex event processing (CEP) events and query definitions for real-time decomposition of resource usage data. Component models specifying measureable characteristics related to an aggregate reading and state(s) into which respective components are enterable are defined. For components that can have plural states, the models further specify valid state transitions, including predecessor and/or successor states. Plausible and composite state definitions are generatable from the component models. The former defines when a CEP engine is to trigger a corresponding plausible state event to signify that a corresponding state is potentially active. The latter corresponds to a representation of two or more component states that potentially are concurrently active. The CEP engine is configured to trigger events based on the aggregate reading and the generated plausible and composite state event definitions.

Abstract: Techniques for auto-executing instructions provided in a video on a computing platform are provided. A script is developed from audio provided in the video. Text shown in frames of the video is extracted. Simulated user interaction (UI) events present in the video are identified. A timeline representation is generated to include entries for elements of the script and the extracted text, and identified UI events. Like elements are collected into common entries. Each entry in the script that lacks an associated UI event but is likely to involve a user action prompt is identified. Each entry having an associated identified UI event, and each entry identified as likely to involve a user action prompt, is converted into a corresponding user action command representation. Each user action command representation is mapped to a computing platform executable command, each being performed using processing resources of the computing platform, automatically, without user intervention.

Abstract: A system for generating training datasets is provided. The system uses base images to generate a large number of images that include non-defective and defective characteristics. The generated images are then used to train a model that may be used to predict defects in real world images of a manufacturing process.

Abstract: Certain example embodiments relate to web applications. In certain example embodiments, an instance of a web application is executed using a client device. In response to the instance being started up, metadata is retrieved using a service embedded in the application and invoked at a bootstrap hook. The metadata is associated with earmarked programmatic elements in the application. At the client device and using an evaluation service injected into operation of the instance, one or more configured rules are evaluated against input. The rules are definable in relation to the earmarked programmatic elements using the retrieved metadata. They specify behavior of the web application and are dynamically (re)configurable while the instance of the web application is running. The (re)configured rules are dynamically effective without requiring web application redeployment, even if (re)configured while the instance of the web application is running. The instance is controllable responsive to the evaluation.

Abstract: Certain example embodiments relate to techniques for building a contextual recommendation engine. Flow representations indicating how services are to interact with one another are received. Each service represents a program logic segment. Flow representations are parsed to identify invocation and conditional processing operations therein. These identified operations are arranged in a predefined format including sequences. Each sequence corresponds to a respective flow representation and includes any identified operations in an order matching their occurrences in the respective flow representation. For each identified conditional processing operation, each identified invocation operation associated with a branch thereof is merged into a single path for inclusion in the respective sequence in place of the respective identified conditional processing operation. Each sequence is converted into a listing of atomic units.

Abstract: Certain example embodiments relate to service mesh management. A service mesh proxy routes incoming requests to one or more microservices in a container. At least one microservice has one or more associated API twins, each definable to enforce a policy based on application-level context information unavailable from incoming requests. A microgateway hosting the API twin(s) is instantiated and is configurable to automatically and transparently ensure that (a) incoming requests that otherwise would be directed to an end microservice having one or more associated API twins will be re-directed to an appropriate one of these one or more API twins en route to the end microservice, and (b) outgoing responses that otherwise would be directed by each such end microservice to the service mesh proxy will be re-routed to the microgateway en route to the service mesh proxy. Incoming requests' structures are unchanged pre- and post-microgateway runtime.

Abstract: In a database system, an archive table data specifies a pre-defined archive time period based on which a periodic archive procedure is performed and a pre-defined purge time period based on which a periodic purge procedure is performed. Based on the periodic archive time period being reached, a new partition is created in a transaction database, which is used as a live partition into which the database stores transaction records which are new; and an expired transaction database partition is moved to the archive database using a database partition feature whereby data in the partition is moved as a whole. Based on the periodic purge time period being reached, an expired archive database partition is removed from the archive database using the database partition feature, wherein data is deleted as a whole from the archive database based on the archive database partition being removed.

Abstract: A computer system is provided that automatically generates a natural language processing model from a provided API specification. Intent names are based on operation type and name. Entity datasets are constructed based on the generated intent name. A plurality of training phrases are generated based on the entity dataset and an action dataset with a name and corresponding parameters is generated.

Abstract: Certain example embodiments involve accessing data in a database. At least one key is associated with the data. The data is indexed based on the at least one key. The index provides key-value pairs in which keys in the key-value pairs correspond to the at least one key associated with the data and values in the key-value pairs correspond to deserializable serialized blobs generated to include the data in variant data type format. The variant data type format includes different possible equivalent representations of the data such that the data stored in the blobs is of potentially different structures. Responsive to a request received from a computing device, a database transaction is performed on the data in connection with the index and based on the received request. These techniques can be used in connection with tasks as well as data “per se.” O(1) performance is achievable in some instances.