It's release time - ready or not - 7.x is in the starting gate !

In a nutshell, here is what's new in the 7.0 development release:

  • With new internal mechanics, Transparent Activation mode has become a no-surprises mode: When you access an object or it's members, you can rely on the object being activated, whether its class implements Activatable or not.
  • With our new enhancer, tuning classes for Native Queries and for Transparent Activation becomes pure pleasure.
  • We include two collections, a List and a Map, that implement Activatable out-of-the-box.

This is a development release, so don't expect everything to be 100% finalized. Missing from this release:

  • .NET functionality is trailing slightly. We will release db4o 7.0 for .NET shortly when our msbuild enhancer and two rudimentary Activatable generic collection implementations (IList and IDictionary) are done.
  • We plan to integrate Transparent Activation as seamlessly as possible into standard JDK and .NET collections and to use algorithms underneath to optimize collection performance for db4o persistence ("Fast Collections").

If you already are an experienced db4o user, you may want to dive directly into how the new functionality is used. Here is a link to an online copy of the (Java) tutorial that comes with the download. Chapter 9 is on Transparent Activation and chapter 15 is on the new Enhancer.

In case you have not used db4o before, here is a short introduction to what "Activation", "Native Queries", and "Enhancement" are all about. Let's take a look at the terms:

  • Activation
    Imagine a graph of objects that is to be loaded from a db4o database. When your program accesses members on the root of the graph, would it be a good idea to load the complete graph into memory? If the graph is deep, this could take a long time and a lot of memory. db4o provides functionality to load all the members of one object at a time when they are needed. We call the process of loading these members "Activation".
  • Native Queries
    Native Queries are a fully typesafe, refactorable and compile-time checked approach to express queries with object-oriented native syntax of the programming language. Under the hood, programming language expressions are analyzed and converted to use database indexes wheneverpossible. Read more here.
  • Enhancement
    For both of the above to work transparently, the byte-code of your compiled application needs to be analyzed and "enhanced", to take advantage of the capabilities that db4o provides. The "Enhancer", available as an Ant script or as a Java app, is provided to integrate the enhancement task seamlessly into your IDE. Once installed, you can continue to work exactly like you did before, your db4o applications will simply be faster and use less memory.

With the 7.0 development release we have brought all three technologies a big step forward in a way that adheres to our key guidelines following the philosophy of our product, namely:

  • An application developer should not have to write code for persisting objects himself. It is the job of our product to do all the work for him.
  • The programming language is the standard. A perfect object database uses the available concepts of the programming language and adds as little as possible own arbitrary semantics.
  • Ease of use does not come at the cost of performance. On the contrary, an automated object persistence system can be superior to hand-written persistence both in terms of performance and memory consumption.

"Now that all sounds like cool technical stuff, but how does it really help me to get my project done on time and make my customer happy?"
Let's try to phrase the benefits of the new features from the user perspective:

  • You can keep your application code completely clean of concerns when and how objects are loaded from the database.
  • Use of db4o with deep objects graphs has become easier by an order of magnitude, because you no longer have to take care about object activation in your code.
  • Your application will run faster and will consume less resources because it only loads the objects it needs at the time it needs them.
  • The new enhancer can be run as a builder in your IDE, optimizing classes and Jars in-place. You will not have to change your IDE work habits in any way to benefit from Transparent Activation and optimized Native Queries.

The first db4o 7.0 for Java development release will be available here shortly.

Enjoy trying it out!

The best way to influence our product to become exactly as you would like it to be is by commenting in our forums.