Archive for January, 2008
Transparent Persistence
+ Transaction Processing…
Smalltalk is pure object-oriented programming for complex business and technical applications, but the benefits of this can be lost in the well-known ‘impedance mismatch’ with relational databases.
The VOSS open source virtual object storage system extends Smalltalk with integrated database management, providing transparent multi-user access and transaction processing of persistent, versioned, Smalltalk objects directly accessible by normal programming, with efficient persistent Btree collection classes, including the multi-key/multi-value/key-set VirtualDictionarySet for aggregation and query-building.
- Multi-process, multi-machine transactional access to distributed objects
- ACID transactions with two-phase commit, logging and rollforward crash recovery
- Persist clustered complexes of any Smalltalk classes except block closures
- Historical object versioning, MVRC repeatable read, MVCC concurrency control
- Automatic object locking with transaction rollback & retry on deadlock time-out
- Automatic change detection, no lock conflicts with sub-transactions, short read-locks
- Multi-key/multi-value/key-set Btree VirtualDictionarySet with query-building methods
- Continuation Transactions manage alternative futures for design or what-if
- Long Continuation Transactions may be persisted prior to ultimate commit/rollback
- Web server / application process rendezvous
- Distributed copying, parented copying, identity-exchange, checkout, read-only etc
- 24×7 operation, with concurrent variable-rate incremental foreground & background garbage collection and snapshot backup of the set of distributed virtual spaces.
- Up to 150 logged & flushed transactions per second on desktop hardware
- Terabyte 64-bit object id and addressing default, configurable up to 128-bit
- Dual Licensing - Open Source GPLv3 and/or Supported Commercial Licence
…Seamless Smalltalk Solutions 
(C) Logic Arts Ltd 2009
Where do you keep your behavior? Normalised in the application domain objects? In non-domain transaction-performing classes? Some of each? I seem to remember this question being touched on once long ago in Digitalk’s Compuserve forum, but never since.
One of the benefits of a persistent object database is that not only static integrity constraints but arbitrarily complex procedure can be expressed just once in the appropriate application domain object, rather than being scattered and/or replicated in a number of external function oriented procedures - normalisation of procedure, in other words. However, the downside of this is that if an intensively used method is located in a domain class of which there are relatively few instances, then those objects may become locking hotspots which destroy concurrency, even though they themselves may not be changed, merely carrying transactional responsibility.
At the other extreme, locating transaction procedures in non-database objects which call only get & set methods in the domain objects, maybe with simple integrity constraint methods, imposes no additional constraint on concurrency, but at the cost of additional work during application design and modification, to ensure that update transactions are all consistent with each others’ implied integrity constraints.
Design by CRC cards (class, responsibility, collaboration) would seem to identify the theoretical location of transaction responsibility, but how does this work out in practice? Are there common patterns from which guidelines might be found for these design decisions?
Join the forum discussion
on this post 