Abstract: Certain example embodiments relate to a computer system for performing a map reduce sequence. Nodes therein include at least one processor and memory and are divided into at least mapper and reducer nodes. Each mapper node executes a map function on input to generate intermediate output elements. Each said intermediate output element includes a first key-value pair. Each element key includes associated map and reduce task identifiers. Each element value includes substantive data, organized as another key-value pair. The intermediate output elements are stored to memory. Each reducer node: retrieves at least intermediate output element values from the memory of a given mapper node, using specified map and reduce task identifiers; stores the retrieved element values to its memory; executes a reduce function on the retrieved element values, in order; and outputs a result from the reduce function for the map reduce sequence. Disk operations advantageously are reduced or eliminated.

Abstract: Certain example embodiments described herein relate to techniques for processing XML documents of potentially very large sizes. For instance, certain example embodiments parse a potentially large XML document, store the parsed data and some associated metadata in multiple independent blocks or partitions, and instantiate only the particular object model object requested by a program. By including logical references rather than physical memory addresses in such pre-parsed partitions, certain example embodiments make it possible to move the partitions through a caching storage hierarchy without necessarily having to adjust or encode memory references, thereby advantageously enabling dynamic usage of the created partitions and making it possible to cache an arbitrarily large document while consuming a limited amount of program memory.

Abstract: A system for distributed business process tracking includes a client adapted to receive a first notification and a second notification, a first provider adapted to perform a distributed business process using a first process, generate a first notification based on the first process, and send the first notification to the client, a second provider adapted to perform a distributed business process using a second process, generate a second notification based on the second process, and send the second notification to the client, and wherein the first provider sends the first notification to the client independently of the second provider or the first provider sends the first notification to the client using the second provider.

Abstract: Certain example embodiments relate to techniques for detecting anomalies in streaming data. More particularly, certain example embodiments use an approach that combines both unsupervised and supervised machine learning techniques to create a shared anomaly detection model in connection with a modified k-means clustering algorithm and advantageously also enables concept drift to be taken into account. The number of clusters k need not be known in advance, and it may vary over time. Models are continually trainable as a result of the dynamic reception of data over an unknown and potentially indefinite time period, and clusters can be built incrementally and in connection with an updatable distance threshold that indicates when a new cluster is to be created. Distance thresholds also are dynamic and adjustable over time.

Abstract: In certain example embodiments, heterogeneous cloud-store provider access systems (HCPAS), and/or associated methods, are provided. Certain example embodiments provide users with managed access to cloud stores distributed across multiple, disparate providers, in a device-independent manner. A common API and user-friendly user interface allow for a single sign-on access to the various providers. Advantageously, users need not download and install differing cloud store provider access software for each provider, device, and/or provider-device combination, used to access the cloud drives. Instead, by using the HCPAS, a user can manage the distributed storage and provide improved common access, e.g., in terms of administrative and operational functions.

Abstract: Certain example embodiments relate to systems and/or methods for cloud-based event-driven integration, which in essence inverts the current point-to-point integration pattern by using an event-driven system in its place. Certain example embodiments transform and normalize integration patterns in connection with an underlying framework that helps decouple data producers from data consumers and advantageously allows additional systems to simply “plug into” the framework. Data from event sources is transformed into an event with a well-defined event type that may be picked up by an event sink, transformed into a format relevant for that event sink, and subsequently processed.

Abstract: Certain example embodiments relate to large venue surveillance and reaction systems and/or methods that take into account both subjective emotional attributes of persons having relations to the large venues, and objective measures such as, for example, actual or expected wait times, current staffing levels, numbers of customers to be serviced, etc. Pre-programmed scenarios are run in real-time as events stream in over one or more electronic interfaces, with each scenario being implemented as a logic sequence that takes into account at least an aspect of a representation of an inferred emotional state. The scenarios are run to (a) determine whether an incident might be occurring and/or might have occurred, and/or (b) dynamically determine a responsive action to be taken. A complex event processing engine may be used in this regard. The analysis may be used in certain example embodiments to help improve customer satisfaction at the large venue.

Abstract: Certain example embodiments relate to a highly-concurrent, predictable, fast, self-managed, in-process space for storing data that is hidden away from the garbage collector and its related pauses. More particularly, certain example embodiments relate to improved memory management techniques for computer systems that leverage an off-heap direct-memory data store that is massively scalable and highly efficient. The off-heap store may be provided in connection with a Java-based environment, and garbage collection may be completely or nearly completely avoided for the off-heap store. The off-heap store may be integrated into a tiered storage solution in certain example embodiments.

Abstract: Certain example embodiments relate to techniques for real-time generation of temporal comparative and superlative analytics. For instance, certain example embodiments analyze real-time events to generate building blocks that are assemblable into natural language question templates. These natural language question templates, which may include natural language phrases and templated fields, may be comparative or superlative in nature. User selectable options or parameters may be inserted in place of the templated fields, and complete questions, including user selections and the comparative or superlative, may be translated into a formal query language for execution on the real-time data source. In certain example embodiments, a GUI may enable users to build pre-constructed questions with selectable parameters.

Abstract: Certain example embodiments described herein relate to techniques for processing XML documents of potentially very large sizes. For instance, certain example embodiments parse a potentially large XML document, store the parsed data and some associated metadata in multiple independent blocks or partitions, and instantiate only the particular object model object requested by a program. By including logical references rather than physical memory addresses in such pre-parsed partitions, certain example embodiments make it possible to move the partitions through a caching storage hierarchy without necessarily having to adjust or encode memory references, thereby advantageously enabling dynamic usage of the created partitions and making it possible to cache an arbitrarily large document while consuming a limited amount of program memory.

Abstract: Certain example embodiments relate to memory management techniques that enable users to “pin” elements to particular storage tiers (e.g., RAM, SSD, HDD, tape, or the like). Once pinned, elements are not moved from tier-to-tier during application execution. A memory manager, working with at least one processor, receives requests to store and retrieve data during application execution. Each request is handled using a non-transitory computer readable storage medium (rather than a transitory computer readable storage medium), if the associated data is part of a data cache that is pinned to the non-transitory computer readable storage medium, or if the associated data itself is pinned to the non-transitory computer readable storage medium. If neither condition applies, the memory manager determines which one of the non-transitory and the transitory computer readable storage mediums should be used in handling the respective received request, and handles the request accordingly.

Abstract: A system, method and computer program product to enable graphical modeling of business processes. KPIs may be defined as part of the design procedure of forming the process. Once defined, the definitions of the KPIs may be included in deployable units and provided to a runtime environment.

Abstract: Certain example embodiments described herein relate to techniques for processing XML documents of potentially very large sizes. For instance, certain example embodiments parse a potentially large XML document, store the parsed data and some associated metadata in multiple independent blocks or partitions, and instantiate only the particular object model object requested by a program. By including logical references rather than physical memory addresses in such pre-parsed partitions, certain example embodiments make it possible to move the partitions through a caching storage hierarchy without necessarily having to adjust or encode memory references, thereby advantageously enabling dynamic usage of the created partitions and making it possible to cache an arbitrarily large document while consuming a limited amount of program memory. Such techniques may be extended to enable atomic updates to be processed efficiently, e.g.

Abstract: Certain example embodiments relate to an intelligent messaging grid for Big Data ingestion and/or associated methods. Each node in a network of nodes is dynamically configurable to send and/or receive messages using one of brokered and brokerless communication models. At least some of the nodes have a complex event processing (CEP) engine deployed thereto, the CEP engines being configured to operate on messages received by the respective nodes and being classified as one of at least two different types of CEP engines. For each message received by a given node that is to be forwarded to a further node along one of multiple possible paths, the given node is configured to route the message to be forwarded to an intermediate node in one of the possible paths. The intermediate node is selected by the CEP engine of the given node based on metadata associated with the message to be forwarded.

Abstract: Certain example embodiments provide efficient policy-based access to data stored in memory tiers, including volatile local in-process (L1) cache memory of an application and at least one managed (e.g., non-volatile) in-memory (L2) cache. Operations include receiving an access request for access to a data element in L2; detecting whether a copy of the data element is in L1; if so, copying the data element and the access policy from L2 to L1 and providing the user with access to the copy of data element from L1 if the access policy allows access to the user; and if not, determining, by referring to a copy of the access policy stored in L1, whether the user is allowed to access the data element, and, if the user is allowed to access the data element, providing the user with access to the copy of the data element from the L1 cache memory.

Abstract: Certain example embodiments described herein relate to techniques for observing an internal state of a software application executing in a runtime environment. For instance, certain example embodiments include traversing a structure of multiple live data objects in the executing software application; generating a graph of shadow data objects based on the traversing, with each shadow data object of the graph corresponding to a live data object of the executing software application; and providing access to the generated shadow graph via a user interface.

Abstract: Certain example embodiments relate to large venue surveillance and reaction systems and/or methods that take into account both subjective emotional attributes of persons having relations to the large venues, and objective measures such as, for example, actual or expected wait times, current staffing levels, numbers of customers to be serviced, etc. Pre-programmed scenarios are run in real-time as events stream in over one or more electronic interfaces, with each scenario being implemented as a logic sequence that takes into account at least an aspect of a representation of an inferred emotional state. The scenarios are run to (a) determine whether an incident might be occurring and/or might have occurred, and/or (b) dynamically determine a responsive action to be taken. A complex event processing engine may be used in this regard. The analysis may be used in certain example embodiments to help improve customer satisfaction at the large venue.

Abstract: Certain example embodiments relate to a highly-concurrent, predictable, fast, self-managed, in-process space for storing data that is hidden away from the garbage collector and its related pauses. More particularly, certain example embodiments relate to improved memory management techniques for computer systems that leverage an off-heap direct-memory data store that is massively scalable and highly efficient. The off-heap store may be provided in connection with a Java-based environment, and garbage collection may be completely or nearly completely avoided for the off-heap store. The off-heap store may be integrated into a tiered storage solution in certain example embodiments.

Abstract: Remote Procedure Call (RPC) is implemented using XML-based message encoding wherein elements in the message corresponding to arguments of the RPC are associated with element type indicators selected from a defined set. The type indicators may allow the message itself to identify structural aspects of the message, particularly useful in the context of array elements, but useful for other types of elements as well.

Abstract: Certain example embodiments provide a generic integration framework for connecting on-premises applications with software as a service (SaaS) applications, and/or for integrating the same. The framework of certain example embodiments involves a layered approach (including a Connector Development Kit, connection factory, metadata handlers, and connector services) that helps to, among other things, allow customization of applications in multi-tenant architectures. Design-time wizards help create runtime artifacts and, during runtime, the connector service helps serve as an intermediary between the on-premises application and the cloud service, thereby hiding the complexity of the specific cloud providers. Certain example embodiments advantageously provide a generic and well-integrated solution for connecting an on-premises application to a cloud service in connection with existing containers.