{quote:jpmsi}
They are not the same, because it's one thing to mediate concurrent access to an object's representation in memory, and another is to think that one object can survive in memory though many transactional units, and still represent the correct values that currently live in the persistent store.
{quote}

I'm assuming you only have one representation of the object in memory, and that it can live through various transactions. I think that the problem here is to find out that two transactions used some given object concurrently.\\ 
That could be fixed with object versioning. Each time an object is affected by a transaction is version changes. When committing a transaction, if at least one object doesn't have the same version like the one when he started then, the transaction must be aborted.

{quote:jpmsi}
I remind you once again, that there can exist alternative means to access the persistent store, hence modifying object state. The application may have no way of knowing these changes, unless you implement proper mechanisms.
{quote}

Maybe I'm a radical here but I think that any kind of change should go through the application. No ~~backdoor~~ should be allowed... Why, in the first place, is there the need to do that?