Sunday, May 24, 2009

New video covering DO4 Console Sample

Today we've published a new video covering Console Sample of DO4. It concentrates on such features as:
- Database schema building
- Metadata.Type, Metadata.Assembly and Metadata.Extension tables
- Batched key generation
- LINQ to SQL translation
- Running on built-in in-memory database (IMDB)
- LINQ to query execution plan translation (executable RSE providers).

Take a look at it - hopefully you'll enjoy it. Any comments are welcome.

The future of DO4

After writing a short announcement related to the upcoming release, I understood I definitely should provide much more detailed information related to its future. So let's start:

Nearest plans

With v4.0 final we want to:
- Deliver a version that really includes all the basic features developers need.
- Show it is fully stable.
- Terminate the long-long chain of "[not yet working] v4.0 is updated [but is still not yet fully ready for production]" posts in this blog and get back to to the road of real releases.

And in addition, after releasing v4.0 final,
- We'll carefully plan each subsequent release. Its new features and delivery date will be precisely known.
- All the future updates will be logged in revision history. Actually we already switched to a public DataObjects.Net v4.0 issue tracker nearly one month ago.
- I expect further development will go faster. Luckily, now I don't see such big castles to storm as LINQ - at least, in observable future (6 months or so).

Btw, here is the answer on one of the frequent questions I heard during last months: are LINQ and schema upgarde really worth 9 months of work?


I really hoped we reached this point in September-October, but was wrong. Frankly speaking, I really thought our internal RSE queries will be enough usable to start, or we'll be able to make them usable enough. But they were not, and all our ideas on how to make them better were looking pale in comparison with LINQ implementation. Moreover, it was supported by some of competitors. As you know, finally we've made a decision to get LINQ support ASAP. This was in the end of November. And from this moment we've been putting more and more resources on getting this done: initial implementation (certainly, quite lacky) made by a single person turned into ~ 4*4 man-months spent on the final implementation.

Comparison with some close competitors (LLBLGen Pro, NHibernate) shows this is definitely not the worst case we could get. Good LINQ implementation requires really lots of time, and for now only few products may claim they support LINQ well enough. In our case LINQ implementation was even more complex: as you might know, our LINQ to RSE translation layer produces real query plans, when it translates LINQ queries for index engines. For example, it automatically uses secondary indexes based on query criterias and statistics.

Another complex part (it costs about 20% of LINQ implementation) was upgrade, and v4.0 implements it really almost perfectly - now you can do all you want without SQL. To migrate your storage to the next version, you need just our upgrade hints and, optionally, your own "recycled" persistent types with all the features they integrate. This ensures your upgrade will be both simple and storage-independent. This is one of the most impressive advantages of new DO. I'm going to create a brief video overview of this feature, it will be available until the release.

Summer goals

#1: Number one RAD framework for database application development on .NET.

This summer we're going to show how to build full-featured WPF and ASP.NET applications (e.g. an issue tracker) on DataObjects.Net in 30 minutes or less.

DataObjects.Net, starting from its first version, was explicitly positioned as RAD tool for database application developers. Now we're going to show it really is such a RAD tool again - but certainly, much more powerful and much less limiting.

#2: Number one RAD framework for N-tier database application development.

The nearest feature we'll bring is integrated storage synchronization. It must dramatically simplify the development of N-tier database applications. Moreover, this summer we'll show file system provider for DataObjects.Net. In fact, a regular database implemented as our indexing engine. It will be initially positioned to be used mainly on the client side, but in future - who knows...

#3: Support the biggest part of RDBMS market.

We'll implement Oracle and MySQL support. Together with already supported RDBMS, they cover more than 90% of the market.

Media activities

This is one of our most annoying lacks. I understand we advertise ourselves quite bad from this point. Almost no articles, rather complex documentation and so on. Why?
a) Frankly speaking, until this moment we had nothing we could honestly write about. "We have really perfect ORM + IMDB, but unfortunately it can't be used in production because it destroys everything on any launch" - LOL, OMG and so on ;)
b) None of us, including me, are good article writers. At least in English.

Everything else seems a consequence of two above facts. No good articles on our web site = no articles on other sites = no exposure. But:
- v4.0 final fully eliminates a)
- b) can be eliminated only if we'll make ourselves to do this well.

If we'll really get b) resolved, we have a good chance to initiate a chain reaction. If not, it doesn't matter how cool is the tool we develop at all. It will sink unknown.

So what we'll do:
- Get #1 goal (full-featured application done in less than 30 minutes) implemented ASAP. This must be really impressive.
- Publish good video covering samples and features of DO4. I hope to finally get the production rate of our "home video" to one file per week at least.
- Eliminate most of the "red links" in our Wiki.
- Publish short articles covering interesting topics lying around ORM tools. For example, comparison of ORM framework performance, implemented LINQ features, discussion of verious features and approaches. Certainly, we'll be mostly on our own side. But if someone of our customers will decide to use the material to write and and publish an article e.g. at the, we'll definitely favor this.

Announcement: DO4.0 final

Hi everyone! We're glad to announce we've finally reached the point when we can fully honestly say we're ready to release DataObjects.Net v4.0 final. This will happen on the first week of this summer.

v4.0 final will include:
- All you can see in the currently available preview
- Almost ideal LINQ implementation
- Almost ideal schema upgrade API
- Providers for Microsoft SQL Server, PostgreSQL and our built-in in-memory database.

Everything else, including sync, additional providers, UI related tools, full-text indexing and search and so on will be released as the set of subsequent minor updates (v4.1, v4.2 and so on).

See the next post for further details.

Tuesday, May 05, 2009 0.4 release

We are glad to announce first preview of, which is our new product targeted to simplify web application development. This product is on early development stage now, but it is ready to get first impression. Its source code, live demo and documentation are available at For now it is absolutely free.

Saturday, May 02, 2009

DataObjects.NET v4.0 got LINQ and upgrade API

Only quick info for now, details will follow tomorrow:
- Almost complete LINQ support. Now only 12 tests out of almost 700 for LINQ are falling (~ about 15 are ignored), so we consider this part is 90% done. List of currently existing issues and lacks will be published shortly. See updated Console Sample - now it executes a bit more complex queries.
- First working version of our cool upgrade API. There are much more issues for now - e.g. it works only on SQL Server, understands results of our schema comparison layer only partially (for now it can't translate move or rename actions for columns and tables) and so on. But there is working Upgrade Sample utilizing this part of API, including IUpgradeHandler. We bet you dreamed about nearly this feature in v3.9 ;)
- We've started to work on our query optimizer for indexing storages. You can see what it already can do in Consile Sample - take a look on RSE queries it dumps on In-memory Storage, and you'll find we already automatically utilize secondary indexes! So if you even dreamed about storing indexed objects in memory and use LINQ to query them, we've just brought this to you. Obviously index access optimization isn't the only one we run - right now we support nearly the same optimizations as SQLite can do.
- There are some other new features, e.g. CachedQuery. To get some query cached, just wrap it into CachedQuery.Execute(() =>[YouOriginalQuery]). Btw, we implemented this pattern better than in EF - we don't require you to write a parameterized lambda here, and thus allow to use cached queries "in place".

That's all the brief description. Have a nice weekend!

P.S. Installers are already updated.