Techniques for performing constructor accessibility checks during deserialization are disclosed. A system receives a command that requires deserializing a serialized object of a target type. The system determines an ancestor type of the target type. Without calling any constructors and regardless of whether the ancestor type is serializable, the system determines whether a constructor of the ancestor type is accessible to the target type. The system deserializes the serialized object only after determining that the constructor of the ancestor type is accessible to the target type.

A method for loading objects from hash chains. A version chain of a class for a serialized object is located in an instance block of an instance chain. A class version of the serialized object is compared to a current version of the class. When the class version of the serialized object matches the current version of the class, a runtime object is loaded by deserializing the serialized object. When the class version of the serialized object does not match the current version of the class: one or more field values are extracted from the serialized object; a converter function is applied to the one or more field values to generate one or more converted field values; and a runtime object that matches the current version is loaded with the one or more converted field values.

A computer implemented method of data access to data stored in one or more data stores includes receiving a request to retrieve data from the one or more data stores; extracting characteristics of the request to classify the request according to a request classification; identifying a model for execution of one or more queries to one or more data stores; executing the one or more queries according to the model to formulate a response to the request, wherein the model for execution is identified based on a class of the request and includes an identification of one or more data stores to which the one or more queries are to be directed to formulate the response; and monitoring execution of one or more queries for a class of request and revising the model in accordance with predetermined criteria.

Exemplary embodiments may provide an automated approach for processing an input data sample to yield a set of object classes, a parser and one or more unit tests for input data that is to be integrated into a data lake. The objects may be readily queried and, in some instances, may be Plain Old Java Objects (POJO's). The exemplary embodiments may process an input data sample to better understand the format of the input data. The input sample may be processed to identify entities, such as records, objects or the like, in the input data sample. The input data sample may be processed on a line by line basis to identify fields in the entities. Once the format of the input data is determined from the input data sample, a parser may be generated to parse the input data.

Implementations are disclosed herein for enhancing swizzling technology. In at least one implementation, functions are hooked by modifying their machine code implementations to jump to a central callback function. The central callback function may then route to other target functions that serve to replace the hooked functions. In another implementation, the machine code implementations are modified to jump to intermediate functions. The intermediate functions invoke dispatch functions that can call into a central callback function. The central callback function may return to the hooked functions.

Example implementations relate to persistent virtual address spaces. In one example, persistent virtual address spaces can employ a non-transitory processor readable medium including instructions to receive a whole data structure of a virtual address space (VAS) associated with a process, where the whole data structure includes data and metadata of the VAS, and store the data and the metadata of the VAS in a non-volatile memory to form a persistent VAS (PVAS).

Techniques for controlling reactivation of service functions are described. Implementations, for example, enable various ways of controlling and storing service objects that provide service functions.

At design-time, an owner data object and a container reference object are defined. At runtime, an instance of the defined owner data object an instance of defined relationship construction parameters are instantiated. At runtime, an instance of the defined container reference object and an instance of a defined data source object are instantiated using the instantiated relationship construction parameters. At runtime, an instance of a defined target data object is instantiated by calling an interface of the instantiated data source object. At runtime, the instance of the target data object is cached in the instance of the container reference object.

The present disclosure is directed to persisting values in a computing environment, particularly using computer programs that run on a virtual machine. An illustrative method includes first launching a computer program, preferably within the environment of a virtual machine. The method further includes loading a plurality of classes associated with the computer program into memory by way of a special class loader. This class loader scans at least one class of classes loaded into memory for at least one persistence-annotated field within that class. The special class loader further writes byte code into a class that contains the at least one persistence-annotated field. The byte code that is added to the class causes a first object that is later instantiated from the at least one class to have the persistence-annotated field.

A ledgered repository of persistent data objects is replicated on a network of persistent storage systems (PSSs) by transactions recorded across multiple blockchains. The blockchains are replicated on each of the PSSs. Using multiple blockchains enables greater parallelism; however, use of the multiple blockchains requires using measures that ensure that transactions distributed across multiple blockchains are applied in way that ensures a level of transactional consistency. Furthermore, the measures are efficient, thereby reducing overhead of maintaining a level of transactional consistency and increasing throughput of applying the transactions using multiple blockchains.