Tougher Than the Rest

Warning and apology to the English reader in advance: Some of the linked content is available only in German.

Tonight was a great evening at the .NET Developers Group Stuttgart: Ralf Westphal, a renowned Solution Architect MVP in Germany, held his talk about O/R mapping in general and Versant Open Access .NET in particular.

I’m not such a big fan of the ORM pack these days, so I approached the talk with much resentment and prepared some hard and picky questions.

Unfortunately for me, Ralph was able to address some of the issues before I even had the chance to start ranting.

It goes to show that the guys over at Versant are really deep into object-relational mapping. They are going the enhanced route, that is, they have a post-compilation step that enhances the IL code with data access for the persistent classes. This makes for almost static mapping performance (proof pending).

Not coincidentally this is exactly like JDO; Open Access grew in Java Land. And it still uses JDBC under the hood to allow for a common code stream with the Java version.

So we need very few and very generic attributing, no common base class, some code for scoping and transaction control and, tada, now we have OO and database talking.

A Visual Studio integration takes care of maintaining the mapping information in a config file, which is being embedded in the assembly. Of course, the mapping can be overridden by app.config.

Furthermore, we have OQL queries and fetch groups. For the lazy, there is forward and reverse schema generation.

There is a seemlessly working disconnected object container that supports binary serialization. Remember what I said about the common code stream of Open Access Java and Open Access .NET? Guess what!

Conclusion:

  1. Versant Open Access .NET is tougher than the rest. It even has some stuff that Paul Wilson can’t match (proof pending, though).
  2. I confess: ORM not considered harmful. It can save you some time building your DAL.

To my great enjoyment, I also had the chance for an extended discussion with Ralf. Eventually he came up with a wonderful learning hook: a topic that is magically The Thing That Brings It All Together™: services, concurrency and, of course, OO and databases, ontologies and the Semantic Web, J2EE and the CLR.

It’s name is Tuple Space. Really Shared Really Virtual Memory.

Yes, Eliza. I’ll elaborate on that.

Later.

Advertisements
This entry was posted in Best practices. Bookmark the permalink.

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s