Abstract: A computer program product embodied on a non-transitory computer readable medium of a control system includes a firmware program file, a signature detection module that causes a processor to detect whether a pre-defined signature is present; a booting module that causes the processor to perform, after it is determined that the pre-defined signature is not present in the main block, operations of power management and pin initiation included in the booting sequence; and a flashing module that causes the processor to perform, in response to receipt of a flashing command, a flashing operation that includes overwriting the firmware program file with an update firmware program file.

Abstract: Systems and methods are described for receiving at an intermediary entity a token from a data provider that enables access to a user's data at a data provider, where the token is received without an intermediary entity receiving user credentials. A request is received from a data recipient to receive data from the data provider, where the token is required to access the data. Data may be received from the data provider using the token, and the received data may be filtered based on a data directive associated with the data provider, to identify which data the data recipient is permitted to access. The identified data may be provided to the data recipient.

Abstract: The present disclosure relates to systems and methods of multi-processing core processing of image frames during image encoding. The multiple processing cores may be connected via dedicated interfaces and transfer neighbor data between the processing cores to enable parallel processing of frame data. The multiple processing cores may each process quad-rows of image data for a single frame in parallel to reduce memory usage and mitigate latency in video encoding.

Abstract: The reliability of an application is improved by analyzing and implementing changes to application infrastructure that is represented, in some examples, as Infrastructure as Code (“IAC”). The system performs various tests on the infrastructure to determine how the infrastructure responds to failures and whether recovery procedures and monitoring services in place are effective and functioning properly. Various examples provide a measure of infrastructure resiliency that can be used to evaluate potential changes to application infrastructure.

Abstract: Described herein is a computer implemented method for maintaining a configurable project hierarchy. The method comprises creating a new hierarchy level data record and storing the new hierarchy level data record in a data store. The method further comprises receiving a request to associate a particular issue type with the new hierarchy level and, in response, creating a new hierarchy/issue type association data record including an identifier of the particular issue type and an identifier of the new hierarchy level identifier.

Abstract: In accordance with the present approach, a library management system identifies third-party libraries that developers request to incorporate into a software release. The library management system may determine whether a master ticket or usage ticket for a new third-party library exists. If a master or usage ticket is not already existing and approved for the third-party library, the third-party library management system may automatically analyze the third-party library to determine whether it corresponds to third-party libraries that are already approved and stored in a central repository. After approval of a master ticket, the third-party library may be incorporated into the central repository and referenced by subsequent usage tickets that are particular to an individual software release. If not approved, the library management system provides the third-party library to a manual approval system.

Abstract: An information system using active context technology allows a user to view and interact with a large amount of data disposed within multiple objects with relative ease, minimal time, and minimal interaction. An active context object allows an active context window to display labels, identifiers, and links for objects that are actively (e.g. presently) contextually associated with each other. Contextual association of objects can be determined by a user, inferred by the nature of each object, or automatically determined by an information system. In another embodiment, an active context window is persistently displayed to a user to allow the user to easily obtain information about contextually associated objects and easily allow the user to navigate among contextually associated objects. In one embodiment, the active context object can be transmitted to other users to allow each user to access contextually related objects and, thus, contextually related information.

Abstract: Apparatus, systems, and methods for a generic firmware-based kernel library mechanism are disclosed. An example apparatus includes a compiler to compile kernels into an executable and linkable format, an image generator to generate library images from executable and linkable format locations, a reducer to retrieve a library image, the library image retrieved starting from a first section of an existing library, the retrieved library image to be used as a platform for developing a new kernel library, a selector to select kernels to include in the new kernel library, one or more libraries organized into a defined number of kernel banks, the kernels combined based on intended application development, and a linker to link a library start function pointer to the library start function, the library start function positioned within the library image, the pointer incorporated in a first section of the library image.

Abstract: The current invention provides a system and method for Data Owners to share with Data Seekers extracted insights from the Big Data, instead of raw data or anonymized raw data, thus reducing or eliminating privacy concerns on the data owned by the Data Owners. An Oblivious Pseudo Random Function (OPRF) is used, with operations using OPRFs occur over encrypted data, thus Data Owners learn only the primary object from Data Seeker and nothing else about the remainder of Data Owners' data. Similarly, Data Seeker learns a list of associated secondary objects and nothing else about Data Owners' data. The extent of sharing can be limited using a predefined threshold depending how much private information Data Owner is willing to share or Data Seeker is willing to pay.

Abstract: A discovery application may obtain, from a remote storage system configured to host storage structures, first data that identifies relationships among the storage structures. The discovery application may generate, based on the first data, a mapping of the storage structures, store the mapping as one or more configuration items, and provide, to the remote storage system, instructions configured to cause the remote storage system to notify the discovery application of modification events associated with the storage structures. The discovery application may receive, from the remote storage system, a notification of a modification event associated with a particular storage structure of the storage structures and, in response, obtain, from the remote storage system, second data that identifies a modification to the particular storage structure. The discovery application may modify the mapping based on the second data and store the modified mapping by updating the one or more configuration items.

Abstract: Fine-grained parallelism within isolated object graphs is used to provide safe concurrent operations within the isolated object graphs. One example provides an abstraction labeled IsolatedObjectGraph that encapsulates at least one object graph, but often two or more object graphs, rooted by an instance of a type member. By encapsulating the object graph, no references from outside of the object graph are allowed to objects inside of the object graph. Also, the encapsulated object graph does not contain references to objects outside of the graphs. The isolated object graphs provide for safe data parallel operations, including safe data parallel mutations such as foreach loops. In an example, the ability to isolate the object graph is provided through type permissions.

Abstract: An augmenting system for augmenting a program's original class with an augmenting class is provided. In some embodiments, the augmenting system receives a definition of an augmenting class that includes a data member. The augmenting system generates resolution code for the computer program. The resolution code is for accessing a reference to an original instance of the original class and providing a reference to a corresponding augmenting instance of the augmenting class. When processing a statement of the computer program that accesses the data member using the reference to the original instance, the augmenting system generates access code for the computer program. The access code uses the resolution code to retrieve the reference to the augmenting instance for the original instance and accesses the data member based on the retrieved reference to the augmenting instance.

Abstract: A system for adding security data to a search index comprises a processor and a memory. The processor is configured to select an object in a search index, wherein an entry associated with the object is stored in the search index and add security entity data to an entry of the search index corresponding to the selected object. A memory is coupled to the processor and is configured to provide the processor with instructions.

Abstract: A discovery application may obtain, from a remote storage system configured to host storage structures, first data that identifies relationships among the storage structures. The discovery application may generate, based on the first data, a mapping of the storage structures, store the mapping as one or more configuration items, and provide, to the remote storage system, instructions configured to cause the remote storage system to notify the discovery application of modification events associated with the storage structures. The discovery application may receive, from the remote storage system, a notification of a modification event associated with a particular storage structure of the storage structures and, in response, obtain, from the remote storage system, second data that identifies a modification to the particular storage structure. The discovery application may modify the mapping based on the second data and store the modified mapping by updating the one or more configuration items.

Abstract: A client-side component of a journal-based multi-data-store database identifies an application schema corresponding to a first application whose data is stored at the database. The application schema includes a writes section indicating a data object to which writes are to be issued from the first application. A journal schema defining one or more data objects for which a concurrency-control protocol is implemented by a journal manager of the database is obtained. Before a transaction request of the application is submitted to the journal manager, the client-side component verifies that the application schema is compatible with the journal schema.

Abstract: A discovery application may obtain, from a remote storage system configured to host storage structures, first data that identifies relationships among the storage structures. The discovery application may generate, based on the first data, a mapping of the storage structures, store the mapping as one or more configuration items, and provide, to the remote storage system, instructions configured to cause the remote storage system to notify the discovery application of modification events associated with the storage structures. The discovery application may receive, from the remote storage system, a notification of a modification event associated with a particular storage structure of the storage structures and, in response, obtain, from the remote storage system, second data that identifies a modification to the particular storage structure. The discovery application may modify the mapping based on the second data and store the modified mapping by updating the one or more configuration items.

Abstract: Declarations of annotation types, which specify annotations, are themselves annotated by meta-annotations. Meta-annotations define constraints based on modular encapsulation.

Abstract: A method and computing device for enablement of a disabled profile or a third party application associated with the disabled profile on the device, the method including receiving, at an identity module on the device, a request to enable the disabled profile or the third party application; obtaining, from each profile on the device that is currently active, a respective policy; obtaining, from the disabled profile, a policy for the disabled profile; determining, based on the respective policies obtained from the active profiles and based on the policy for the disabled profile, whether the disabled profile or third party application can be enabled; and providing a response to the request to enable the disabled profile based on the determining.

Abstract: An augmenting system for augmenting a program's original class with an augmenting class is provided. In some embodiments, the augmenting system receives a definition of an augmenting class that includes a data member. The augmenting system generates resolution code for the computer program. The resolution code is for accessing a reference to an original instance of the original class and providing a reference to a corresponding augmenting instance of the augmenting class. When processing a statement of the computer program that accesses the data member using the reference to the original instance, the augmenting system generates access code for the computer program. The access code uses the resolution code to retrieve the reference to the augmenting instance for the original instance and accesses the data member based on the retrieved reference to the augmenting instance.

Abstract: Implementing aspects via callback in a virtual machine, where an aspect weaver weaves the aspect with a module to provide primary and crosscutting functionality in the runtime execution of the module. The virtual machine has multiple modules that are part of an application implementing separation of concerns. Each of the multiple modules has a distinct functionality portion and a common functionality portion, common to all modules. The common functionality is referenced by the virtual machine via callback for the multiple modules. Aspect code is loaded as a callback that is applied to the multiple modules by the virtual machine. Loading the aspect code as a callback can implement the aspect at any point in the modules, including conditional statements, calls to methods of objects or classes, loops, any point in an exception handler, or to monitor changes in variables.

Abstract: A system for scaling visualizations may include a human machine interface (HMI) configured to display a visualization on a screen, a secondary display device configured to display a scaled visualization such that the scaled visualization is determined based at least in part on the visualization, and a controller. The controller may be configured to receive an indication that the secondary display device has been coupled to the HMI, present two or more scaling mode options on the screen or the secondary display device, receive an input that corresponds to one of the scaling modes, generate the scaled visualization by applying a scaling factor to the visualization, wherein the scaling factor is based at least in part on the input, and facilitate sending the scaled visualization to the secondary display device.

Abstract: In general, a specification of multiple contexts that are related according to a hierarchy is received. Relationships are determined among three or more metadata objects, and at least some of the metadata objects are grouped into one or more respective groups. Each of at least some of the groups is based on a selected one of the contexts and is represented by a node in a diagram. Relationships among the nodes are determined based on the relationships among the metadata objects in the groups represented by the nodes, and a visual representation is generated of the diagram including the nodes and the relationships among the nodes.

Abstract: An interactive television system is provided in which targeted messages may be sent to users. The interactive television system may use an interactive television program guide or other interactive applications to provide interactive television services to users. An e-mail or other messaging application may be used to receive the messages. The messaging application may be separate from the program guide or other interactive television application or may be part of the program guide or other interactive television application. Messages may be targeted based on the television channels to which the user subscribes or based on which settings the user has established in the program guide or other application or based on any other suitable criteria.

Abstract: An information-processing device includes: a storage unit that stores parameter types used in executing application proms, each parameter type associated with an identifier of an application program; a setting unit that sets a value for a parameter used in executing a first application; a determination unit that determines, based on an association between the identifiers and parameter types, which association is stored in the storage unit, at least one second application program that uses a parameter of a parameter type the same as a parameter type for which a value is set by the setting unit; and an incorporating unit that incorporates the value for the parameter set by the setting unit into a value for a parameter used in executing the at least one second application program determined by the determination unit.

Abstract: Systems and methods are disclosed herein to a computer-implemented method for communicating with peripheral devices comprising loading, by a computer, a configuration file specifying supported peripheral devices and defining commands for each supported peripheral device; receiving, by a computer, a selection of one of the supported peripheral devices from a list of peripheral devices presented in an interface; calling, by a computer, a device handler for the selected peripheral device; invoking, by a computer, protocols for the selected peripheral device that are specified by the device handler corresponding to the selected peripheral device; and sending, by a computer, commands entered through the interface to the selected peripheral device using the invoked protocols of the device handler corresponding to the selected peripheral device.

Abstract: A non-transitory computer-readable recording medium that stores a user interface program for developing application software using a graphical user interface (GUI) developing unit configured to cause a user to develop application software via a GUI. The user interface program causes a computer to function as a command-line user interface (CUI)-based GUI control unit configured to control the GUI developing unit via a CUI. The GUI developing unit is configured to operate in response to an input event generated by manipulation of an input device, and the CUI-based GUI control unit is configured to pseudo-generate the input event via the CUI.

Abstract: In developing applications for a plurality of node types, a meta-data definition of the application can be captured into an application definition module. The meta-data definition can describe the application for the plurality of node types. A code generation module can then automatically generate the application code for the plurality of node types, including transaction aware code. The code can be compiled per node type and the packaging necessary to deploy the application to the plurality of node types can also be automatically generated.

Abstract: A mechanism is disclosed for operating local version-independent service program code for infrastructure services, wherein the mechanism is automatically and optionally linked to a central, remote service infrastructure, and wherein both an online and an offline processing mode is included and automatically supported, and wherein the mechanism is embedded in a generic runtime environment. In at least one embodiment, it contains service program code implemented in the runtime environment for calling by way of the application program code with standardized interfaces, wherein the service program code is intended for the provision of functionalities for predetermined services that an application program code can use.

Abstract: A file containing code for customizing a server's functionality can be “hot plugged” into the server without requiring server restart. The file is added in a class path of its own. The server's class path is not modified during this process, and, consequently, the server does not need to be shut down or restarted. Changes are made to the class-loading pattern of a JVM. Whenever the JVM starts, the JVM's own container class loader component loads the classes. Custom plug-in jar file code is loaded by a parallel class loader that executes in parallel with the container class loader. When the parallel class loader is started, the container class loader is made the parent of the parallel class loader. Because the container class loader is made a super class of the parallel class loader, components loaded by the parallel class loader become recognized by the parent container class loader.

Abstract: According to an example implementation, a computer-readable storage medium, computer-implemented method and a system are provided to receive a first class, the first class indirectly implementing a first interface, wherein the first class extends a second class that directly implements the first interface, identify one or more directly implemented methods within the first class, determine a method signature for one or more of the directly implemented methods, estimate that the first class indirectly implements the first interface based on the method signatures for the one or more directly implemented methods, and instrument the first class based on the estimating that the first class indirectly implements the first interface.

Abstract: The disclosed embodiments provide a system that facilitates the development and execution of a software program. During operation, the system obtains a type interval for a generic type parameter of an implementation of an overloaded function. Next, the system selects an inference direction for the generic type parameter based on a variance of the generic type parameter, wherein the inference direction is an upward inference direction or a downward inference direction. Finally, the system uses the type interval and the inference direction to perform type inference on the generic type parameter.

Abstract: A method to instrument program code for a virtual machine that comprises, in the course of loading a class to a virtual machine, adding code to the class to declare a field that corresponds to a field declared in a first bootstrap class.

Abstract: A system, method, and medium are disclosed for implementing an application component container. The container is configured to detect that a component managed by the container is dependent on an interface that is implemented by a dynamic module provided by a dynamic module system. The container uses a dependency injection framework to inject the implementation into the dependent component in a type-safe manner.

Abstract: A method and data processing system are disclosed for concurrently loading a plurality of new modules while code of a plurality of modules of an original (i.e., currently running) computer program is loaded and executed on a computer system. The method may comprise allocating a module TLS block for each thread within an initial computer program, wherein the allocated module TLS blocks are large enough to hold all module thread variables that are loaded or to be loaded. The method further may comprise providing constant offsets between module TLS block pointers corresponding to the module TLS blocks and the module thread variables for all of the threads. The disclosed method may be used to add modules to the original computer program and/or to apply a concurrent patch by replacing one or more of the plurality of original computer program modules.

Abstract: Various embodiments are directed to systems and methods for optimizing energy use with one or more optimization engine objects. An optimization engine object may have a plurality of dependent objects including at least a dependent optimization engine object, or at least one of a supply-side or demand-side object. The optimization engine object may receive dependent object attribute data from each of the at least one dependent objects; determine an optimal configuration for the plurality of dependent objects over the first time period subject to at least one optimization constraint; and conditioned upon the optimization engine depending from a superior optimization engine, transmit a net energy usage associated with the optimal configuration to the superior optimization engine.

Abstract: A field device management apparatus may include a plurality of COM in-process servers, each of which acquires and manages device data related to a corresponding one of field devices, and a launch-program COM in-process server that stores a launch-program, the launch-program activating an instance in each of the plurality of COM in-process servers, the launch-program preventing four different functions from being executed directly by an OS in the plurality of COM in-process servers. The plurality of COM in-process servers may be initialized on the Microsoft Windows operating system to generate COM objects in different memory spaces.

Abstract: A multi level virtual function table uses a hierarchy of chunks or segments of virtual function tables to identify methods for a particular class. At least one level of indirection pointers may point to individual virtual function table chunks, which may be shared by multiple classes. In some embodiments, fixed size chunks of virtual function tables may be used, other embodiments may use variable sized chunks of virtual function tables. In just in time compiled code, virtual function tables may be limited to sharing across parent and child classes, while in pre-compiled code, more complex sharing may be used.

Abstract: Improved systems and methods for developing rule packs can include receiving monitoring rules specified in a markup language, and combining them to produce a rule pack. Combining processes can leverage product development processes such as Integrated Development Environments (IDEs), thereby allowing any number of developers to work on the same rule pack simultaneously. Common settings may be added to rule packs in an automated, platform-specific way, thereby eliminating the need for rule writers to concern themselves with such common settings. Rule packs may be converted from a markup language to a binary file for use by a monitoring service.

Abstract: A hybrid system is provided. The system includes a computing device implementing a first application execution environment (AEE) and a second AEE. The first AEE is configured to be isolated from the second AEE. The first software application associated with the first AEE is configured to be processed on the first AEE such that the first software application is denied direct access to the second AEE. A second software application associated with the second AEE is configured to be processed on the second AEE such that the second software application is denied direct access to the first AEE.

Abstract: A system and method for optimizing the object code of a computer program is disclosed. The method includes receiving one or more object code units from the memory; identifying first and second identical program entities in the one or more object code units, wherein each program entity has an object code segment and an associated address; updating the one or more object code units by merging the first identical program entity with the second identical program entity if neither of the first and second program entities is subject to an operation on the respective program entity's address; and linking the updated one or more object code units into an executable program.

Abstract: There is provided an information processing apparatus including a message storage unit for storing a message sent to a component, and an execution processing unit for loading the component body into a computer in response to receiving an execution instruction on the component to execute the component body and process the message stored in the message storage unit prior to the execution instruction.

Abstract: Methods for runtime control of hierarchical objects are provided. Certain embodiments provide kinematics procedures in a media content, runtime environment. Making these procedures available in the runtime environment allows the variables of the kinematics procedures to be specified at runtime, for example by the end user or by a runtime-executed script. One exemplary method comprises receiving a hierarchical object for a piece of media in a media content authoring environment and providing the piece of media to one or more runtime environments. The piece of media provided to the runtime environments comprises both object information about the hierarchical object and kinematics procedural information for performing kinematics on the hierarchical object, such as procedural classes for performing inverse kinematics procedures based on runtime-provided end-effector and target point variables.

Abstract: Disclosed herein are methods and systems for using on stack replacement for optimization of software. A source code is compiled into an unoptimized code on a computing device. The unoptimized code is then executed on a computing device. A hot count is incremented. It is then determined whether a function within the unoptimized code is hot. If a function is determined to be hot, an OSR triggering code is inserted at a back edge of each loop within the function. The OSR triggering code is configured to trigger OSR at a loop depth that is less than the hot count.

Abstract: Methods, systems, and apparatus, including computer program products, for implementing a software architecture design for a software application implementing self-service procurement used to procure goods and services “ad hoc” by requests from within an organization. The application is structured as multiple process components interacting with each other through service interfaces, and multiple service interface operations, each being implemented for a respective process component. The process components include an Accounting process component, an Internal Request Processing process component, a Purchase Request Processing process component, a Purchase Order Processing process component, a Goods and Service Acknowledgement process component, a Supplier Invoice Processing process component, a Payment Processing process component, an RFQ Processing process component, and a Due Item Processing process component.

Abstract: Systems and methods for compiling one or more code blocks written in programming language are provided. In some aspects, display associated with application is provided. Display includes plurality of graphical objects. That each of plurality of graphical objects is associated with child code block in one-to-one association between graphical objects and child code blocks is determined. Each child code block is written in programming language. The child code blocks associated with plurality of graphical objects are transformed into single parent code block. Parent code block, upon compiling, is configured to be reused across execution contexts and to allow injection of global scope. Parent code block, upon specific execution, includes execution context for specified child code block. Parent code block is configured to receive indication of specified child code block for initiating execution of parent code block. Parent code block is compiled.

Abstract: A computer-implemented method, system, and medium is disclosed for implementing a hybrid application server. The server is configured to determine that a bundle deployed onto a dynamic module system defines a component that is manageable by an application server component container. In response to the determining, the application server deploys the component onto the component container and creates an instance of the component in the container so that the container can manage the component. Finally, the application server registers a proxy handle to the component as a service in the dynamic module system. Thereafter, the proxy handle is discoverable and invocable by another component.

Abstract: Class loader changes from at least one user-defined class loader to a bootstrap class loader are determined by a stack processing module during de-serialization of a serialized data object. A reference to each user-defined class loader is stored separately from a thread method frame stack in response to each determined change from the at least one user-defined class loader to the bootstrap class loader. For each user-defined class load operation of a user-defined class associated with the de-serialization of the serialized data object, a latest user-defined class loader (LUDCL) is identified using the stored reference and the user-defined class is loaded using the identified LUDCL.

Abstract: A method for storing a data file associated with a source code file of a firmware program in an EFI environment is provided. The method involves converting the data file to an object file as well as converting the firmware source code file to an object file. An executable file is then created from the object file of the data file and the object file of the firmware source code file. Once created, the executable file may be stored in a file of a firmware storage device.

Abstract: Integrating a new class into a class hierarchy is disclosed. A new class having a place in a class hierarchy is received. Metadata, associated with the new class, that includes the new class's place in the class hierarchy is also received. Hierarchy data associated with a previously compiled class is dynamically modified to reflect the place of the new class in the class hierarchy.

Abstract: A code sequence made up multiple instructions and specifying an offset from a base address is identified in an object file. The offset from the base address corresponds to an offset location in a memory configured for storing an address of a variable or data. The identified code sequence is configured to perform a memory reference function or a memory address computation function. It is determined that the offset location is within a specified distance of the base address and that a replacement of the identified code sequence with a replacement code sequence will not alter program semantics. The identified code sequence in the object file is replaced with the replacement code sequence that includes a no-operation (NOP) instruction or having fewer instructions than the identified code sequence. Linked executable code is generated based on the object file and the linked executable code is emitted.