Processing XML in Java usually requires a lot of code and overhead. If you use XQuery, you can do a lot more with a lot less code, even when the XML is stored outside of XML databases. Learn how to use XQuery with Java technology by extracting the hidden information from XML-based Maven POM files.

How do you manage the history of data in an open, decentralized system, like for example the Internet? CVS, Subversion, WebDAV or versioning file systems help you to remember old versions on one specific server. GIT, Mercurial and others let you do that in a decentralized, less dependent way, but the data needs to be managed in individual projects. In documentation systems, like Wiki servers, CMS systems, data history is seen as a key feature. These histories are managed centralized and scoped on one document only. In this article I'm going to analyze different aspects of the data history in a decentralized system and try to model a corresponding concept.

Often, an existing database application must evolve rapidly by incremental steps. Alex describes a tried and tested system to provide an automated approach to deploying both new and existing database systems, whilst dealing with common security and configuration issues.

This article shows how to use Spring MVC with a popular object relational mapping (ORM) framework called Hibernate. ORM is becoming the most popular way to manage a Java application's persistence layer. An ORM framework maps your database tables to objects in the application with the same name, making the application much easier to construct and maintain. In short, ORM decouples your business-logic layer from your database. With ORM, you use the framework's SQL on your domain model objects—not on the actual database tables. With this type of development, you can change your application's database (for example, from Oracle to SQL Server) without making code changes to your queries, saving a good amount of time.

This is part three of a series. In this installment, I discuss how testing is different in the database world from in software.

This article covers some basic techniques to optimize the performance when working with an ORM and still getting all the benefits of Object-Relational mapping

This is part one of a series of articles. In this installment, I try to reconcile the fact that databases cannot evolve (individuals do not evolve) and the need for databases to respond to change in an agile environment.

Developers are flocking to Ruby on Rails at an incredible pace. There's a great reason for this migration: Rails provides a robust framework built on one of the most flexible languages ever conceived. One of the tricks in the Rails bag is the concept of "Migrations." Migrations provide an excellent example of why developers would want to use the framework, and here's why: Generally speaking, managing changes to a database schema has been one of the most odious tasks for a team of developers. Most have relied on storing DDL in revision control, ever vigilant to ensure that our database creation scripts are updated and consistent with each rollout. That solution can be very clumsy in an Extreme Programming project. And because Rails encourages iterative development, it would be very easy to imagine the constant schema changes turning into nightmares. Fortunately, Migrations allows a developer to manage rollout, and rollback, of database schema changes in a controlled and consistent manner, and one that happens to feel very natural to a Rails programmer.

Databases are often out of sync with the applications they support, and getting the database and data into a known state is a significant challenge to manage. In this installment of Automation for the people, automation expert Paul Duvall demonstrates how the open source LiquiBase database-migration tool can reduce the pain of managing the constant of change with databases and applications.

Object persistence is a must in almost all Java™ applications, from the desktop to the enterprise. The downside of persistence is that it has never been particularly simple. But that has changed with the most recent version of Simple Persistence for Java, an open source library for object-relational persistence. Simple Persistence for Java version 2.1.0 adds support for HSQLDB, a 100% pure Java database. Neither Simple Persistence for Java nor HSQLDB requires administration or configuration from the application user. Taken together, these tools enable you to introduce persistence to your applications with very little work. This article introduces you to Simple Persistence for Java v2.1.0 and shows you how to use it to achieve almost effortless object persistence in your Java applications.