db4o Developer Community

Performance Contest - for one more month

Carl Rosenberger — Thu, 17 Jul 2008 10:38:00 GMT

Do you like profiling? Do you like tuning code? If you do, how about taking part in the db4o performance contest? We offer USD 6000 in prizes for the best contributions to make db4o faster.

We have made it very easy for you to get started by providing an Eclipse workspace set up with the db4o sources and the Poleposition benchmark.

Links to get you started:
Performance Contest page
"Getting Started" video
Performance Contest Forum

The contest has been running for a month already and we are seeing first contributions coming in.

Andrew has improved sorted queries and provides a UTF-8 string encoder.
Erik is working on a query cache to make queries reusable.

Can you beat their patches? I am sure you can.
The contest is still open for contributions for one more month until August 15.

Implications of instrumenting assemblies for Transparent Activation / Persistence in db4o - Part I

Adriano Verona — Mon, 14 Jul 2008 14:28:00 GMT

As the popular saying tell us, there's no such thing as free lunch. It is no different for work related subjects.

When we introduced Transparent Activation (TA) concept we knew that it could make developer's life easier (by presenting a simpler model for object life cycle): developers would not be required to think about activation depths again; just let db4o activate your objects when it's need.

IMHO, it was a great improvement since it not only simplifies developer's life as well brings some performance gains also (once objects get activated only when needed there's no wasted time activating objects not needed). But this was not without coasts: to benefit from this simpler model, developers were required to implement IActivatable interface for each object that they wanted to be TA. Also, once enabled, any non TA aware object will be fully activated at retrieval time.

Time passed and we introduced a way relieve developers from the need to implement Activatable interface, i.e, to make classes TA aware with no effort from developers. This is accomplished through a technique called instrumentation in which we dive into byte code level doing something like:

Find each type declared in a specific assembly (.net) / jar or class (java)
Analise each type found in step 1 to check whether it is a potential candidate for TA or not
If we found a potential candidate for TA

Make the type to implement IActivatable interface
Implement IActivatable methods
Ensure that the object will be activated prior to any field access by inspecting each field access in this type and inserting the required Activate() / activate() call prior to it.

Save the binary component

A pretty straight approach, I'd say.

But even when using instrumentation there are some implications that developers should be aware of. To illustrate, think about assembly signing; this is a process in which a developer "seals" an assembly contents by digitally signing it (the whole concept is beyond this post).

Basically, by signing an assembly a developer is providing ways to administrators to selectively grant access to assemblies based on the private key (related to the public key) used to sign it; also, signed assemblies are tamper resistant which means that changes (in byte code level) don't go unnoticed.

By the above description it's clear that instrumenting a signed assembly turns it invalid afterward (since its contents gets changed) and any tentative of loading it will fail with a invalid signature error.

So, after instrumenting signed assemblies you will need to sign them again but, IMHO, you should never, ever, instrument assemblies that are not under your control, so I'd suggest you to just change your build scripts so instrumentation takes place prior to signing.

To help developers detect this, starting from version 7.4.52 Db4oTool will emit an warning when asked to instrument (whether for TA/TP or Native Queries optimizations) a signed/delay signed assembly.

Just for the sake of completeness I've included the following walk through on how to create assemblies that are instrumented and signed (for a in depth discussion on signing assemblies please, read this).

In Visual Studio, open project properties window and select signing tab.
Select Sign the assembly;
Expand Choose a strong name key file drop down listbox and either, select a previously created key or create a new one by selecting <New...> option;
Select Delay sign only checkbox;
Save your project and build
Instrument your assembly (either running Db4oTool or through Db4oToolEnhancerMSBuildTask)
After instrumentation, run sn tool as follows to finish the sign process:

sn -Ra myassembly.dll mykey.snk

That's it! Your assembly is instrumented and signed.

In the next post I'll address some other implications / pitfalls regarding instrumentation for TA/TP.

Thoughts?

Users comment on O/R Impedance Mismatch

German Viscuso — Wed, 09 Jul 2008 19:26:00 GMT

ODBMS.ORG, a vendor-independent non-profit group of high-profile software experts lead by Prof. Roberto Zicari, today announced the exclusive publication of a new series of user reports on using technologies for storing and handling persistent objects:

http://www.odbms.org/downloads.html#odbms_ur

11 user reports have been published, from the following users:

Gerd Klevesaat, Siemens
Pieter van Zyl, CSIR
Philippe Roose, Liuppa
William Westlake, SAIC
Stefan Edlich, TFH Berlin
Udayan Banerjee, NIIT
Nishio Shuichi, ATR Labs
John Davies, Iona
Scott Ambler, IBM
Mike Card, Syracuse
Rich Ahrens, Merrill Lynch

Prof. Zicari asked each users a number of equal questions, among them if they had an "impedance mismatch" problem. Each time data models, e.g. relational models, are used to persistently store data and the program language used, e.g. in object-oriented Java, are different, this is referred to as the "impedance mismatch" problem.

Users confirmed in different ways the existence of such a problem.

Enjoy!

Enhanced db4o support in latest DataNucleus Access Platform 1.0 M3

German Viscuso — Sun, 06 Jul 2008 23:24:00 GMT

DataNucleus Access Platform 1.0 M3 is released (see the announcement). The main things affecting usage with db4o are :-

The original JDOQL implementation has been superceded by a new "generic" implementation supporting more of the JDOQL syntax
Support for querying via JPQL is added.

Newsletter #43: db4o Announces its First Performance Contest - Win $6000 in prizes!

German Viscuso — Sat, 28 Jun 2008 23:36:00 GMT

db4o 7.4 Development Release is available for immediate download!

A R T I C L E S

db4o Announces its First Performance Contest - Win $6000 in prizes!

· As part of our commitment to improving db4o's performance we're organizing this hands-on contest where community members can contribute and benchmark patches to the db4o core and win out of 6000 USD in cash prizes

· The rules and deadlines are available in the Performance Contest page

· A full set of tools to provide for a smooth start and a "leveled playing field" has been carefully prepared for the contestants (we're providing a "Getting Started" video and a full Eclipse workspace so you can be up and running in no time).

· We encourage you to use the Performance forum for questions related to the contest

Create your own db4o Distribution

· Building a full db4o distribution will allow you to get the same db4o packages as you can get from db4o download center. However, the flexibility of the build project also allows you to get only parts of it, like only java distro, only documentation, only tests etc.

· Now you can learn how to build db4o by yourself. This will allow you to implement enhancements and come up with your custom modifications of the engine.

· The generation of db4o .NET sources is achieved through "Sharpen" which can be used for any application to automate conversion of Java sources to C# - get started using the conversion tool and give us some feedback the Sharpen forum

Read Committed Isolation and Pushed Updates - Revisited

· db4o guarantees that any query will return objects in their most recently committed state - unless they are still in memory on the client (i.e. on the reference cache)

· To help you handle this last scenario we've introduced Commited Callbacks for providing Pushed Updates (i.e. notify a client that objects have been changed via events)

· In this blog we provide code snippets for doing Pushed Updates while using db4o in embedded client-server mode (code is also compatible with the networked C/S mode)

To Flush or not to Flush

· In order to provide consistency a database must flush its data cache frequently (and db4o is no different in this sense)

· db4o used to allow users to disable the flushing via Configuration.flushFileBuffers(false) but we're now discontinuing this configuration switch and providing a brand new NonFlushingIoAdapter which makes the risk of database corruption smaller (as it used to be in db4o 6.1)

· Don't forget that there's always a trade-off between speed and consistency (to disable flushing might lead to a corrupted database file if your system is halted during the commit phase) so use the new IO adapter with care

· This new IO adapter is already available in our latest development version

Improved Read Performance by Profiling with JProbe

· In our latest paircast (a step by step video) you'll learn how to use JProbe to improve performance in your applications

· In this session you'll see how this tool helps db4o developers easily find a way to increase "read" performance by 30%

· If you have any comments about the profiling session or any performance related feedback please don't hesitate to use the Performance forum

· And don't forget that you can test drive JProbe for FREE, see JProbe's on-demand webcast and their weekly Live Demo. You might also want to check the new JProbe white papers

Highlighted Contributions

· func4: func4 allows you to use db4o for authentication through the JAAS spec for Java applications. It has been used for webapps in Tomcat 5 and Jetty 6. Currently it should be considered in beta

· db4oBackup: a community contributed tool to schedule automated backups of a db4o db. Configuration is done through a config.xml file where you specify the source and target directories. More info here (in Spanish)

· DataNucleus: DataNucleus Access Platform 1.0 M2 has just been released with a JDO/JPA API for db4o (read more here). Main things of interest to db4o users in this release are:

o Added support for db4o "embedded server" mode (contrib from Joe Batt)

o Zip file of Access Platform specifically for db4o, including bundled db4o-6.1 (GPL)

· Groovy and db4o: In this blog post, db4o Netbeans plugin creator Gerd Klevesaat explains how to use db4o under Groovy (through a builder implementation by the author). The post includes links to download the builder and source code examples

Paircast of the Month

· "How to Build db4o" (on-line version) takes you step-by-step through the process of building db4o yourself

"Paircasts" are video recordings of "live pairing sessions" of db4o core team, designed to provide deep understanding of db4o code and practices. You can download the paircasts or see them on-line and subscribe via different services

E V E N T S

· Wednesday, July 2, 2008 - Munich, Germany
Join the training course by db4o creator Carl Rosenberger (in German) sponsored by Ralf Westphal and Zoschke. Training will be .NET-centric, covering topics such as db4o based application development, transparent persistence, queries with LINQ, speed optimization and more...

K U D O S O F T H E M O N T H

[db4o] really is a no-brainer to work with. And yet, it’s not a trite system either. Database experts will be interested to know if db4o offers multi-threading, flexible indexing, atomic transactions and other such things. The answer to these is yes; it is high performance and maintains integrity of its data.

David M Williams, 6/11, ITWire

L O O K I N G I N T O T H E M I R R O R

"db4o Sharpens its Image"
ITWire.com, May 23, 2008

"Rapid Linux apps using object databases"
ITWire.com, June 11, 2008

www.db4o.com
newsletter@db4o.com
Phone +1 (650) 577-2340
1900 S Norfolk Street, Suite 350
San Mateo, CA 94403 (USA)

PRIVACY NOTE: We respect your privacy. If you do not wish to receive our monthly newsletter, please send an email to unsubscribe@db4o.com with "UNSUBSCRIBE" as the subject.

New Performance Contest - help us make db4o ultra fast!

German Viscuso — Fri, 27 Jun 2008 23:03:00 GMT

We invite you to participate in the db4o performance contest which will give away 6000 USD in prizes!

Basically participants will provide patches to the db4o core that impact on performance and then these modifications will be judged by the community to select the winners. In order to make the whole process easier we're providing the following:

Eclipse Workspace Distribution
Paircast: How to get started (this video is included in the above distribution)
Performance Forum (to provide/get help)

Ideas for possible improvements are:

A UTF-8 String encoder
Improvements to the query processor
- Removal of processed index constraints from the processor so they won't run in the SODA processor
- Class index filtering of the index results to be able to ignore the SODA processor run completely if all constraints are processed
- Index processing of ANDs and ORs over field constraints at difference hierarchy levels
Improving the BTree implementation

MRU cache for BTree pages

The Performance Costest has started already and it ends on August 15 2008.

Please hurry and submit your patch! =)

db4o-7.4 Development Release

Tetyana Loskutova — Tue, 24 Jun 2008 16:03:00 GMT

The following Jira tasks and bugs were resolved for db4o-7.4 development release:

DRS-98 - NullPointerException in replicate method
DRS-97 - Ensure dRS.NET can gracefully handle delegates in untyped fields and arrays
DRS-95 - dRS.NET fails with arrays/untyped fields
DRS-94 - Replication fails if the java platform doesn't support serializable constructor and the objects to be replicated don't have default constructors
DRS-93 - Replication fails for arrays in untyped fields
COR-1297 - Spike: Class derived from ArrayList using custom Typehandler
COR-1295 - Convert ListTypeHandlerTestSuite to .NET
COR-1291 - Backport "[Linq] Enum comparisons are not optimized" to 7.2
COR-1289 - Clean up db4obuild for opening to the public
COR-1284 - Defragment against unknown classes runs into NPE on btree index lookup
COR-1283 - Update old multidimensional arrays to null bitmap handling
COR-1282 - [decaf] functional test for resolving db4oj/db4ojdk1.2 conversion issues
COR-1281 - Running out of disk space causes unrecoverable data corruption
COR-1279 - Delegate in untyped arrays cause ObjectNotStorableException
COR-1276 - prepare Jprobe paircast and blog
COR-1275 - Db4o should not wrap exceptions thrown during event handling
COR-1265 - ArrayHandler: Defragment old databases
COR-1264 - ArrayHandler: Updating from old databases to new format
COR-1263 - ArrayHandler: Bitmap Marshalling Format
COR-1262 - Pass configuration on to reflector on startup
COR-1261 - Move constructor handling into reflector
COR-1255 - Provide Feedback on latest OMG SBQL vs, LINQ comparison
COR-1254 - _blob.ReadFrom() throws Object reference not set to an instance of an object. in C/S mode
COR-1247 - Create releae notes for production release 7.2
COR-1246 - Create release notes for 6.4 stable release
COR-1227 - Prepare 7.2 "Production" release (freeze trunk)
COR-1216 - TracerBullet: Deletion for Java ArrayList using the new Typehandler
COR-1214 - Db server closed when upgraded from 5.5 version to 6.4.14.8331 with btree based freespace management system
COR-1153 - [Linq] Enum comparisons are not optimized
COR-1129 - TracerBullet: Special use cases for Java ArrayList using the new Typehandler
COR-897 - Concurrency tests for close/timout scenarios

flushFileBuffers(false) and the C in ACID

Carl Rosenberger — Wed, 18 Jun 2008 15:24:00 GMT

The short story:
Configuration.flushFileBuffers(false) is no more. If you still want to configure the behaviour that used to be available in db4o 6.1, you can do so by setting up IoAdapters as follows:

RandomAccessFileAdapter randomAccessFileAdapter = new RandomAccessFileAdapter();
NonFlushingIoAdapter nonFlushingIoAdapter = 
                                 new NonFlushingIoAdapter(randomAccessFileAdapter);
CachedIoAdapter cachedIoAdapter = new CachedIoAdapter(nonFlushingIoAdapter);
Configuration configuration = Db4o.newConfiguration();
configuration.io(cachedIoAdapter);
Db4o.openFile(configuration, PATH);

The long story:
We do a lot of things for consistent transactions (for the C in ACID). A commit of a db4o transaction consists of 4 write phases:

Writing a commit log to the database file
Switching the database file to commit mode
Committing all slots
Switching the database file to normal mode

Because a cache at any level may turn around the write order of individual slots and because a failure may end up in a partial write, it is essential that all data is flushed to the device after each one of these 4 phases.

This flush call takes a lot of time. It is the slowest part of the commit. On a system where you are sure enough (100% ? ) that the commit process always is successful, a tuning switch that skips flushing sounds like a smart way to improve performance.

That's what we thought and why we added the #flushFileBuffers(false) configuration switch in the first place.

Starting with db4o 6.4 we have added a new CachedIoAdapter to the IO layer as the default. This IoAdapter uses the #sync() calls as a signal to flush it's pages to the database file. What we did not think about well enough when we added this functionality: If users use the #flushFileBuffers(false) tuning switch, they also skip the flush of the CachedIoAdapter.

This issue does not surface as long as the database file is always shut down correctly, so it took us a long time to realize how serious it can be. Since we have switched db4o 6.4 to "stable", there have been a couple of support discussions like this one:

User: "We have switched to db4o 6.4. We are sometimes getting new exceptions like IncompatibleFileException."
db4objects: "Uhoh. Are you maybe using #flushFileBuffers(false) in productive use? Please don't do that. Don't tell us that you are."
User: "Yes we are."

After investing some time and thought we have figured that the CachedIoAdapter makes it much much more likely that corruption can happen if a database file is not shut down correctly (with the #flushFileBuffers(false) configuration call). Because this is so serious (it leads to corrupted database files), we have decided to turn off this configuration switch completely.

A similar functionality as in 6.1 is still available, if you really know what you are doing and if you know that you are taking the risc of corrupted database files if your system is halted because someone hits the power-off switch by accident in the middle of a commit. With the layer of IoAdapters, as outlined at the beginning of this posting, the risk of corruption is fairly small, just as it used to be in 6.1. Corruption will only happen if the OS cache or disc cache changes around the order of writes.

The changes are effective and the new IoAdapter is available from iteration 48 and revision 10977 onwards, e.g. from db4o versions:
6.4.48.10977
7.2.48.10977
7.4.48.10977

For previous stable 6.4 versions we strongly recommend not to use the #flushFileBuffers(false) setting in production use.

Many thanks to our users for reporting their problems!

Committed callbacks, pushed updates and read committed isolation revisited

Patrick Roemer — Tue, 17 Jun 2008 15:34:00 GMT

Some time ago we presented Pushed Updates as a sample application for Committed Callbacks in this blog. Recently we put a similar mechanism in a slightly different context. Since we encountered some perceived ambiguity concerning db4o transaction semantics, and since we were in for a little surprise ourselves, I'd like to briefly rehash this topic.

Pushed Updates basically are a mechanism to provide READ COMMITTED isolation from the point of view of your application. Wait - doesn't db4o provide that out of the box?!? Well, it does. Any query is guaranteed to return objects in their most recently committed state - unless they are still in memory on the requesting client, that is. db4o cannot change the state of of a live object that may be involved in application level processes at the same time. Only the application can judge whether it is safe to modify a given object, and Committed Callbacks are the way to transfer this responsibility.

Note that "in memory" above does not mean "in use by the application", and not even necessarily "referenced by the application". An object may still survive in the reference system some time after it has been discarded by the application, until the GC eventually hits. There is no remotely performant way to check whether there exist hard references to a given object.

So much for the theory, let's look at the code. The core of the Pushed Updates example looked like this:

private EventListener4 createCommittedEventListener(final ObjectContainer objectContainer){
return new EventListener4() {
    public void onEvent(Event4 e, EventArgs args) {
      ObjectInfoCollection updated = ((CommitEventArgs)args).updated();
      Iterator4 infos = updated.iterator();
      while(infos.moveNext()){
        ObjectInfo info = (ObjectInfo) infos.current();
        Object obj = info.getObject();
        objectContainer.ext().refresh(obj, 2);
      }
    }
};
}

EventListener4 committedEventListener = createCommittedEventListener(client);
EventRegistry eventRegistry = EventRegistryFactory.forObjectContainer(client);
eventRegistry.committed().addListener(committedEventListener);

This code registers a callback for committed events. When invoked, it will traverse all the objects that have been updated during this commit and refresh them. (The magic depth of two is a reverence to collections, forcing them to refresh their elements, too.)

Now this works nicely - in networking C/S mode, where the communication layer between client and server takes care of the correct "translation" of object identities. In embedded C/S mode, however, there is no translation - clients run in the same "live object space" as the server, the only thing they don't share is the weak reference system that defines their notion of object identities. And so the ObjectInfo will contain the server's instance of this persisted object, while the client will have its own version that it won't be able to map to the "stranger".

The fix is easy (and works for networking C/S, too, of course): We have to take care of the translation ourselves via ID lookup. In code:

public void onEvent(Event4 e, EventArgs args) {
Transaction trans = ((InternalObjectContainer)client).transaction();
ObjectInfoCollection updated = ((CommitEventArgs)args).updated();
Iterator4 infos = updated.iterator();
while(infos.moveNext()){
    ObjectInfo info = (ObjectInfo) infos.current();
    Object obj = trans.objectForIdFromCache((int)info.getInternalID());
    if(obj == null) {
      continue;
    }
    client.refresh(obj, 2);
}
}

Here we have to fall back on the InternalObjectContainer interface. Don't be too scared of this - it's not really under the hood stuff, but it's indeed intended to be used for 3rd party implementations of pluggable db4o features intended to be run inside the core, like type handlers, reflectors - and callbacks. Note that this variant also keeps the handler from further processing of objects that haven't been known to this client, anyway.

Bottom line: Transaction semantics and live in-memory objects are not entirely trivial to align, object identities can be tricky, and this is the recommended generic way for doing Pushed Updates. For networking C/S, the original Pushed Updates example is fine as it was.

Groovy and db4o

German Viscuso — Sun, 15 Jun 2008 23:40:00 GMT

In this blog post, db4o Netbeans plugin creator Gerd Klevesaat explains how to use db4o under Groovy (through a builder implementation by the author). The post includes links to download the builder and source code examples.

Thanks Gerd!

First steps with Sharpen

German Viscuso — Sat, 14 Jun 2008 19:29:00 GMT

Well, Adriano Verona's blog post title is really "Running Sharpen Tests" but he also did a great job at introducing the first steps for trying Sharpen (db4o's conversion tool that translates Java code to C# code). As you might know the tool (which is used internally to generate the .NET version of db4o) has been released as open source. Give it a try!

[Kudos] Dead simple

German Viscuso — Wed, 11 Jun 2008 18:40:00 GMT

[When it comes to db4o] by decreasing the complexity of the database a barrier to developers has been removed and in fact deployment is also made easier for the end user.

db4o [...] stores its data in a different way to a relational database. Rather than flat tables with repeated primary key and foreign key values splattered throughout, db4o uses a different model. It builds upon the popular object oriented programming paradigm which will be familiar and comfortable to those who code in C++, Java, Smalltalk, Python and even, on the Windows side, Visual Basic.NET, Delphi and more.

What makes it special are several abilities so cunning you could pin a tail on them and say it’s a field of weasels.

db4o will save slabs of memory to disk with a minimum of fuss.

I am certain you will agree this really is a no-brainer to work with. And yet, it’s not a trite system either. Database experts will be interested to know if db4o offers multi-threading, flexible indexing, atomic transactions and other such things. The answer to these is yes; it is high performance and maintains integrity of its data. db4o does not offer stored procedures but that’s not really an issue; the focus turns back onto putting code within the program and leaving the database to just store data.

If you’re a developer, no matter the platform, give an object database a try and see how it can revolutionise your coding, as well as pave the way for more developers to come across to Linux.

http://www.itwire.com/content/view/18714/1141/

Rapid Linux apps using object databases

German Viscuso — Wed, 11 Jun 2008 18:05:00 GMT

When you think of databases usually MySQL or Oracle or even Microsoft SQL Server come to mind. Yet, object oriented databases have the potential to cut down coding nuts and bolts and speed up app development time – particularly for those migrating to Linux from Windows. Here’s one such compelling SourceForge hosted open source system to do just this -> db4o

(See the rest of the article here: http://www.itwire.com/content/view/18714/1141/)

in ITWire
by David M Williams
Wednesday, 11 June 2008

db4o’s Sophisticated Cross-Platform Translation Tool Converts Java Apps to .NET

German Viscuso — Thu, 05 Jun 2008 02:29:00 GMT

"Sharpen" Increases Market Reach While Keeping a Unified Code Base

SAN MATEO, Calif., May 30, 2008 - db4objects (http://www.db4o.com/), creator of the leading open source object database, has announced that its Sharpen Java to C# source code conversion tool is now available to the public as free software. db4objects has used the tool extensively to generate most of the .NET db4o engine core code and unit test suites from Java sources.

"Sharpen is the 'secret sauce' that enables us to provide the db4o object database engine in native version for the two most popular platforms from a single code base," said Anat Gafni, vice president of engineering at db4objects. "Our decision to release this tool to developers to help them bridge the gap between Java and .NET and create truly cross-platform applications is just one more clear indication of our commitment to the Open Source community."

"The emergence of LINQ is very exciting for developers and we are thrilled to leverage the capabilities of these extensions to allow developers to maintain the full power of complex object structures and the development environment that is often lost or compromised when translating to/from SQL," said Anat Gafni, vice president of engineering at db4objects. "We have optimized our support for LINQ so that queries are executed in a high-performance fashion."

Sharpen gives developers the ability to support both Java and .NET while maintaining a single source code without having to invest in an expensive translation tool. Since the tool has been integrated into db4o's development cycle, it a well tested and mature solution that developers can trust.

"The advantages of maintaining a single source code base cannot be underestimated," said Rodrigo B. de Oliveira, technical lead architect at db4o. "In the development cycle, multiple source bases inevitably start to diverge, and lead to duplicate efforts, and differences in features and quality between the platforms. Once a very challenging task, maintaining a unified code base, and in turn a unified community, now is truly possible."

For developers interested in Sharpen capabilities, the current features include:

Mapping between Java and .NET native type system
Compliance with C# coding conventions
User-defined namespace/class/method mappings
Method to property mappings
Generics support
Partial conversions
Mixing native and converted C# sources
VS solution file support
Ant integration

"Sharpen bridges the gap between our Java and .NET communities," said German Viscuso, db4objects' community manager. "We have been able to effectively receive source code contributions from both Java and .NET developers without having to worry about db4o versions being out of sync. It's simply the best of both worlds!"

The tool is being released under the GNU General Public License (GPL). The subversion repository, documentation and issue tracker are available online. In db4o's Sharpen forum, developers can provide feedback and contributions to increase the availability of automatic conversion of not-yet supported Java constructs and idioms.

For more information on db4objects or any of its products, visit the company's Web site at http://www.db4o.com/ or send an e-mail to: sales@db4o.com. To join the largest open source community on object databases visit developer.db4o.com

About db4objects, Inc
db4objects, Inc (http://www.db4o.com/) provides db4o, the world's most popular object database, native to Java and .NET and available under open source and commercial licenses. With some 35,000 registered community members and well over one million downloads, db4o is used in a broad array of industries around the globe. Customers include the world's most innovative companies, including Boeing, Bosch, Ricoh, and Seagate. db4objects is based in San Mateo, California, and backed by noted Silicon Valley luminaries including Mark Leslie, founding CEO of Veritas; Jerry Fiddler, founding CEO of Wind River; Vinod Khosla, founding CEO of Sun Microsystems as well as Palo Alto-based Asset Management venture firm.

Press and analyst contacts: press@db4o.com

DataNucleus Access Platform 1.0 M2 released with support for db4o

German Viscuso — Sun, 01 Jun 2008 01:24:00 GMT

DataNucleus Access Platform 1.0 M2 has just been released with a JDO/JPA API for db4o. Read more here

Main things of interest to db4o users in this release are:

Added support for db4o "embedded server" mode (contrib from Joe Batt)
Zip file of Access Platform specifically for db4o, including bundled db4o-6.1 (GPL)

Enjoy! (thanks Andy =)

db4o videos to watch on-line

German Viscuso — Fri, 30 May 2008 18:50:00 GMT

Hi! I just wanted to point you to the the blip.tv db4o show.

There we're hosting all db4o related videos for you to watch on-line (including our cutting-edge paircasts!). No need to download the video.

Note that you subscribe to this show via iTunes, Miro, Pando, or RSS (thanks to blip.tv the show is also available in the iTunes Store, just do a search for db4o while in iTunes and you'll get access to all our videos!).

Additionally, if you have a db4o related video which is not there we will be glad to put it in the channel (send me a private message).

Also, feel free to sindicate any of the db4o videos in your website or blog (instructions to do this are available here)

Best regards and enjoy =)

db4o Open Source Object-Oriented Database Supports LINQ

German Viscuso — Fri, 23 May 2008 22:33:00 GMT

Microsoft users can replace SQL database with native ODBMS engine
.NET Developers' Journal News Desk
May. 12, 2008
http://dotnet.sys-con.com/read/564247.htm

db4o Sharpens its Image

German Viscuso — Fri, 23 May 2008 22:33:00 GMT

by Tony Austin
Friday, 23 May 2008
ITWire.com
http://www.itwire.com/content/view/18388/1127/

Next-Generation OO Databases: An Interview with db4objects' Anat Gafni

German Viscuso — Fri, 23 May 2008 22:31:00 GMT

SAN FRANCISCO, Calif., May 9, 2008 – In an interview with Artima during the latest JavaOne, Anat Gafni, VP of Engineering at db4objects, explains how OO databases support agile development, and how they co-exist with relational databases in an enterprise.

http://www.artima.com/lejava/articles/javaone_2008_anat_gafni.html

When to use an Embedded ODBMS (by Rick Grehan)

German Viscuso — Fri, 23 May 2008 20:47:00 GMT

On TheServerSide.com, April 07, 2008
http://www.theserverside.com/news/thread.tss?thread_id=48953

Newsletter #42 - db4o Opens the Coveted "Sharpen" - an Automatic Cross-Platform Translator

German Viscuso — Thu, 22 May 2008 22:19:00 GMT

db4o 7.3 Development Release is available for immediate download!

K U D O S O F T H E M O N T H

"LINQ for db4o is extremely easy to use and very powerful. The learning curve is very low. This article [about db4o and LINQ] only scratched the surface of the possibilities of db4o."

Edwin Vermeer
Senior Software Developer, Mirabeau B.V.

"Embarcadero Technologies' acquisition of CodeGear and the announcement of db4o's support of LINQ are more evidence of the blurring of the lines of application development and database development. Increasingly, application developers want and need better insight and control of the data management aspects of their applications. On the flip side, database administrators are faced with responsibility of ensuring application performance. Common toolsets and better communication can only help both communities achieve their objectives."

Gregory Keller on MetaFrequency
VP-Product Management at Embarcadero Technologies, Inc

A R T I C L E S

-- "Sharpen" Translates your Java Application Sources to C# --

db4o opens its "secret tool" so that everyone can benefit from a super smart db4o created "cross-platform" Java-to-.NET translator. To learn more, and to find the repository, documentation and bug tracking for "Sharpen" read this blog post.
Get started on how to use "Sharpen" with a sample application and short startup guide.
You are all invited to enhance and augment to fit your needs. Please give us your feedback in the Sharpen forum.

-- db4objects' dRS is the First Object Replication on Android --

dRS replication is now working on Android, adding critical value to db4o based Android Applications.
dRS keeps an Android db4o ObjectContainer in sync with another db instance. (either with a server db4o database or a relational database)
Download dRS and try it on Android now!

-- db4objects is Leading a Community Effort to Promote LINQ for Java --

LINQ for Java follows db4objects approach of Native Queries. To know more about this initiative read Carl's blog.
Having a common interface on .NET and Java that is natively supported would create a easy to use, efficient standard for database developers.
To read along or participate in this effort join the JLINQ group.

-- Paircasts - db4objects Innovative Agile Way of Documenting Code, Practices and Design Decisions --

"Paircasts" are video recordings of "live pairing sessions" of db4o core team, designed to provide deep understanding of db4o code and practices. Read more about our paircasts.
A library of db4o "paircasts" is being built for your convenience about specific topics. Check it out, and start downloading here or watch live.
The tagging system on the right helps you find the "paircast" that addresses your topic of interest.

-- Paircast Pick of the Month --

"Working with db4o sources" (live) – this paircast walks you through the fundamentals of working with db4o sources, compiling the project, writing db4ounits test, etc.
This is what you always wanted to know in order to start contributing … let the party begin!

-- JProbe - An Effective Tool to Improve db4o Performance --

Our latest paircast shows how to use JProbe to improve performance for your applications.
In this paircast you'll see how this tool helps db4o developers easily find a way to increase "read" performance by 30%.
Interested in making db4o and your application faster? Please participate in our Performance forum.
Go and get a FREE Trial Download of JProbe.
Check JProbe's on-demand webcast: Best Practices in Java Environment Testing and their weekly Live Demo.
Read the new JProbe white papers: Effective Performance Testing in Enterprise Java Environments and Realizing Continuous Performance Management Best Practices.

-- Highlighted contributions --

ObjectManager contributions: Initial support for working with encrypted databases and saving custom db4o configuration settings has been added to
our community project ObjectManager championed by Gisbert Avellan. Please check the OM Google Code site and/or subscribe to the
OM commits mailing list.
db4o NetBeans plugin author, Gerd Klevesaat shows us how to access db4o databases from Groovy. We welcome your feedback to the db4o-groovy project.
Need to validate your objects before a save/update in a db4o database? Check Dario Quintana's Validator.

-- Events --

May 19, Auburn Hills, Michigan
As an OSGi alliance member db4o attended the OSGi Vehicle Expert Group Workshop where representatives of the Automotive industry gathered to support the OSGi platform as the underlying framework for in-vehicle software. db4objects is the de-facto standard for object persistence.under OSGi and it was well received as a robust, straight forward and lightweight transparent persistence solution for the platform. For more information please check the OSGi Vehicle Expert Group site.
July 2, Munich, Germany
Join the training course by db4o creator Carl Rosenberger (in German) sponsored by Ralf Westphal and Zoschke. Training will be .NET-centric, covering topics such as db4o based application development, transparent persistence, queries with LINQ, speed optimization and more…

L O O K I N G I N T O T H E M I R R O R

"db4o Open Source Object-Oriented Database Supports LINQ". .NET Developers' Journal. May 12, 2008

"An introduction to LINQ for db4o" by Edwin Vermeer. The Code Project, April 28, 2008

"Just Objects No Limits" (live), Carl Rosenberger's talk at ICOODB 2008 in Berlin (video for download)

--------

With best regards

The db4objects team.

www.db4o.com
newsletter@db4o.com
Phone +1 (650) 577-2340
1900 S Norfolk Street, Suite 350
San Mateo, CA 94403 (USA)

Newsletter #41 - db4o Release 7.3 Makes Using LINQ for Object Persistence Easier

German Viscuso — Thu, 22 May 2008 22:15:00 GMT

db4o 7.3 Development Release is available for immediate download!

K U D O S O F T H E M O N T H

"I did not have to do anything to setup db4o to save an object. It just serializes the object to the database. No need to worry about table names, column names or data types. This all comes for free with this engine, allowing a developer to focus on the domain model and the value-add code, rather than data persistence."

-- Eric Hexter in LosTechies.com

A R T I C L E S

-- The efficiency of Transparent Persistence is added to .NET LINQ provider --

db4o features the only optimized LINQ (Language Integrated Native Query) provider for an open source object database > read blog
Transparent Persistence (TP) automatically stores and retrieves just the needed objects > more about Transparent Persistence and Transparent Activation
TP prevents object graph activation issues such as retrieving too many or too few associated objects

-- New "Stable" Release 6.4 is available --

"Stable" releases are of highest quality and stability, suitable for deployment in shipping products. Major highlights include:

Commit time callbacks and pushed updates – to enable client’s object-cache to stay in sync with changes that are committed to the server, and to ensure that certain constraints are not violated
Exceptions - helps developers catch certain conditions and recover from them during execution
Performance – an order of magnitude faster embedded client/server version of db4o

-- New "Production" Release 7.2 is available --

“Production” releases are candidates for "Stable", yet they have more recent features and are recommended for evaluation and development. Highlights of 7.2 include:

Optimized LINQ (Language Integrated Native Query) for .NET
dRS (DB Replication) Collection handling enhancements

dRS now preserves collections’ individual element’s accessibility and integrity after replication on .NET and Java

-- db4o’s Ad-Hoc LINQ Console application offers fun, interactive mode --

Using Ad-Hoc LINQ you can play and experiment with queries and objects interactively
You are invited to enhance it further

-- db4objects Survey results are in --

Our users vouch primarily for performance and scalability.
There’s a clear trend towards more professional db4o users!
Thanks for your participation! The winners are announced (in this blog)!

-- Highlighted contributions --

db4o field generation support > read more
New financial management project with db4o > read more
Maven support for db4o project started > read more

-- Profiling and tuning performance --

Quest Software's JProbe is db4objects' recommended Java profiler, and is used to meet the high demands of db4o users for optimal performance and memory usage.
Go and get a FREE Trial Download of JProbe
Check JProbe's weekly Live Demo
New JProbe White Paper: Best Practices in Java Environment Performance Testing
New JProbe White Paper: Achieving Continuous Performance Management
JProbe's On-Demand Webcasts: Best Practices in Java Environment Testing
Stay tuned to our Paircasts blog for the upcoming profiling paircast featuring JProbe (coming soon!)
To learn about our partners and other technologies used at db4objects see the Partners page.

-- Events --

The db4o User Conference 2008 (Berlin) in March was a big success! > read more

L O O K I N G I N T O T H E M I R R O R

Select press coverage about db4o since the last newsletter:

Object-oriented database programming with db4o - Part 2 (by Buu Nguyen)
The Code Project, March 25, 2008

When to use an Embedded ODBMS (by Rick Grehan)
TheServerSide.com, April 07, 2008

Polytechnic University in Hannover Germany Rehabilitates Injured Athletes and the Disabled with db4o
SAN MATEO, Calif., April 21, 2008 (Press Release)

--------

With best regards

The db4objects team.

www.db4o.com
newsletter@db4o.com
Phone +1 (650) 577-2340
1900 S Norfolk Street, Suite 350
San Mateo, CA 94403 (USA)

Sharpen your Java app now: Java to C# converter released as free software

Patrick Roemer — Tue, 20 May 2008 16:27:00 GMT

As of today, db4objects releases its Eclipse based Java to C# source code conversion tool "sharpen" as free software.

sharpen is the "secret sauce" that enables us to provide the [db4o object database engine] in native versions for the Java and .NET platforms from a single code base.

Features include:

mapping between Java and .NET native type systems
compliance with C# coding conventions
user defined namespace/class/method mappings
method to property mappings
Generics support
partial conversions
mixing native and converted C# sources
VS solution file support
Ant integration

sharpen is used extensively in the db4o build system, generating most of the db4o engine core code and the unit test suites from the Java sources.

Before you start dreaming: sharpen is not a "magic wand". Don't expect to feed it an arbitrary Java app and receive a running .NET version at the push of a button. The translation process will require some design compromises on the Java side, and parts of the .NET code still have to be hand crafted and integrated into the converted sources. Still, we believe sharpen provides an amazingly smooth way to bridge the gap between Java and .NET and create real cross platform applications.

We are looking forward to see which sharpen propelled applications will cross the language chasm, and we're hoping on your feedback and your contributions that will help to cover automatic conversion of even more Java constructs and idioms, moving Java/.NET cross platform integration to a new level.

sharpen is released under the GPL. The svn repository, documentation and issue tracker are online. All that's missing now is you bringing your Java app to the .NET platform. To get you started, here is the full anatomy of a simplistic application developed with sharpen. Have fun!

Paircasts - How we work

Carl Rosenberger — Tue, 20 May 2008 16:07:00 GMT

Have you ever wondered how and when an idea was developed? Would you have liked to see how the corresponding lines of programming code were written to make a dream come true? Are you interested how the people behind the code are like and how they behave when they work together?

Hey, I would really like to know a lot more about many of you guys out there and how you work.

So here is an offer:
When we work on code (usually programming in pairs of two), we record screen and audio of our sessions to make them available for download as videos.

Let's call these videos "Paircasts".

A first selection of 10 recorded sessions is available on our new Paircasts blog. You may want to read "About Paircasts" first. It also tells you where to get a free video player and/or the right codecs.

If you like the idea of Paircasts, please do try to record your own and tell us about them. Our team would love to peek over your shoulder also.

db4o Developer Community

Performance Contest - for one more month

Implications of instrumenting assemblies for Transparent Activation / Persistence in db4o - Part I

Users comment on O/R Impedance Mismatch

Enhanced db4o support in latest DataNucleus Access Platform 1.0 M3

Newsletter #43: db4o Announces its First Performance Contest - Win $6000 in prizes!

A R T I C L E S

db4o Announces its First Performance Contest - Win $6000 in prizes!

Create your own db4o Distribution

Read Committed Isolation and Pushed Updates - Revisited

To Flush or not to Flush

Improved Read Performance by Profiling with JProbe

Highlighted Contributions

Paircast of the Month

E V E N T S

K U D O S O F T H E M O N T H

David M Williams, 6/11, ITWire

L O O K I N G I N T O T H E M I R R O R

"db4o Sharpens its Image" ITWire.com, May 23, 2008

"Rapid Linux apps using object databases" ITWire.com, June 11, 2008

New Performance Contest - help us make db4o ultra fast!

db4o-7.4 Development Release

flushFileBuffers(false) and the C in ACID

Committed callbacks, pushed updates and read committed isolation revisited

Groovy and db4o

First steps with Sharpen

[Kudos] Dead simple

Rapid Linux apps using object databases

db4o’s Sophisticated Cross-Platform Translation Tool Converts Java Apps to .NET

DataNucleus Access Platform 1.0 M2 released with support for db4o

db4o videos to watch on-line

db4o Open Source Object-Oriented Database Supports LINQ

db4o Sharpens its Image

Next-Generation OO Databases: An Interview with db4objects' Anat Gafni

When to use an Embedded ODBMS (by Rick Grehan)

Newsletter #42 - db4o Opens the Coveted "Sharpen" - an Automatic Cross-Platform Translator

Newsletter #41 - db4o Release 7.3 Makes Using LINQ for Object Persistence Easier

Sharpen your Java app now: Java to C# converter released as free software

Paircasts - How we work

"db4o Sharpens its Image"
ITWire.com, May 23, 2008

"Rapid Linux apps using object databases"
ITWire.com, June 11, 2008