Transparent Persistence Research Articles

Persistence Design on English Test Questions Library System Based on Hibernate

English test questions library based on computer technology and English test theories, is a collection of digital test question and test papers, to achieve the scientific and efficient management of test questions and test papers. For difficult problems in college English test questions library system construction, this paper studies the persistence design on English test questions library based on Hibernate. Firstly, research on Hibernate architecture, and through graphics to display; Then, test questions library structure design, including conceptual structure design and logical structure design; Next, the design rules of persistent classes and design examples; Finally, the Hibernate mapping files related elements are described, and carries on the example design. Research method has the object/relational database mapping, transparent persistence, low invasive, good transplantation, and other advantages.

Enhancing source-level programming tools with an awareness of transparent program transformations

Programs written in managed languages are compiled to a platform-independent intermediate representation, such as Java bytecode. The relative high level of Java bytecode has engendered a widespread practice of changing the bytecode directly, without modifying the maintained version of the source code. This practice, called bytecode engineering or enhancement , has become indispensable in introducing various concerns, including persistence, distribution, and security, transparently. For example, transparent persistence architectures help avoid the entanglement of business and persistence logic in the source code by changing the bytecode directly to synchronize objects with stable storage. With functionality added directly at the bytecode level, the source code reflects only partial semantics of the program. Specifically, the programmer can neither ascertain the program's runtime behavior by browsing its source code, nor map the runtime behavior back to the original source code. This paper presents an approach that improves the utility of source-level programming tools by providing enhancement specifications written in a domain-specific language. By interpreting the specifications, a source-level programming tool can gain an awareness of the bytecode enhancements and improve its precision and usability. We demonstrate the applicability of our approach by making a source code editor and a symbolic debugger enhancements-aware.

Interprocedural query extraction for transparent persistence

Transparent persistence promises to integrate programming languages and databases by allowing programs to access persistent data with the same ease as non-persistent data. In this work we demonstrate the feasibility of optimizing transparently persistent programs by extracting queries to efficiently prefetch required data. A static analysis derives query structure and conditions across methods that access persistent data. Using the static analysis, our system transforms the program to execute explicit queries. The transformed program composes queries across methods to handle method calls that return persistent data. We extend an existing Java compiler to implement the static analysis and program transformation, handling recursion and parameterized queries. We evaluate the effectiveness of query extraction on the OO7 and TORPEDO benchmarks. This work is focused on programs written in the current version of Java, without languages changes. However, the techniques developed here may also be of value in conjunction with object-oriented languages extended with high-level query syntax.

Implementation of an object oriented data model in an information system for water catchment management: Java JDO and Db4o Object Database

Object-oriented technologies are playing increasingly important roles in every level of software application for water resource management and modelling, except for data management levels where the relational logic is still the uncontested choice of information system developers despite the object–relational impedance mismatch. In this paper, we would like to present our experience concerning two different technologies for developing the object-oriented data management layer in information systems for water resources management: (i) the Java solution to obtain transparent persistence, the Java Data Object (JDO) technology; (ii) a purer object solution with a light open source Object Database, Db4o. The process for implementing the two technologies in a Java-based hydro-information system is described, and the two different solutions were analysed and compared.

Extracting queries by static analysis of transparent persistence

Transparent persistence promises to integrate programming languages and databases by allowing procedural programs to access persistent data with the same ease as non-persistent data. When the data is stored in a relational database, however, transparent persistence does not naturally leverage the performance benefits of relational query optimization. We present a program analysis that combines the benefits of both approaches by extracting database queries from programs with transparent access to persistent data. The analysis uses a sound abstract interpretation of the original program to approximate the data traversal paths in the program and the conditions under which the paths are used. The resulting paths are then converted into a query, and the program is simplified by removing redundant tests. We study an imperative kernel language with read-only access to persistent data and identify the conditions under which the transformations can be applied. This analysis approach promises to combine the software engineering benefits of transparent data persistence with the performance benefits of database query optimization.

EROS

EROS is a capability-based operating system for commodity processors which uses a single level storage model. The single level store's persistence is transparent to applications. The performance consequences of support for transparent persistence and capability-based architectures are generally believed to be negative. Surprisingly, the basic operations of EROS (such as IPC) are generally comparable in cost to similar operations in conventional systems. This is demonstrated with a set of microbenchmark measurements of semantically similar operations in Linux.The EROS system achieves its performance by coupling well-chosen abstract objects with caching techniques for those objects. The objects (processes, nodes, and pages) are well-supported by conventional hardware, reducing the overhead of capabilities. Software-managed caching techniques for these objects reduce the cost of persistence. The resulting performance suggests that composing protected subsystems may be less costly than commonly believed.

The design of the E programming language

E is an extension of C++ designed for writing software systems to support persistent applications. Originally designed as a language for implementing database systems, E has evolved into a general persistent programming language. E was the first C++ extension to support transparent persistence, the first C++ implementation to support generic classes, and remains the only C++ extension to provide general-purpose iterators. In addition to its contributions to the C++ programming domain, work on E has made several contributions to the field of persistent languages in general, including several distinct implementations of persistence. This paper describes the main features of E and shows through examples how E addresses many of the problems that arise in building persistent systems