The many faces of ownership implementation
Last week's column defined the rule of ownership. Every object has exactly one owner, the object responsible for its creation and destruction. The responsibility of ownership cannot be transferred to another object.
By objects, I'm talking not only in the object-oriented sense. All entities in a software system, from database records to program variables to COM objects, must obey the rule of ownership. These types of objects use referential integrity, scope, and reference counting, respectively, to implement ownership, but the rule is always the same.
RDBMS using referential integrity
Take, for example, ownership among records in a relational database. Ownership defines a strict one-to-many master-detail relationship between tables. No detail record should exist without a master record. To enforce this, we use the facilities of the DBMS to enforce referential integrity. Deletion cascades from master to detail. If you fail to properly define these relationships, you will end up with orphaned records, or worse, lost data.
C++ using scope
In C++ scope helps us define ownership. Define a member variable of class type within another class, and the inner object cannot outlive the outer. The owner intrinsically creates and destroys the owned object. Furthermore, ownership cannot be transferred. The owned object can be copied, certainly, but the copy has unique identity; the copy and the original can be changed independently. Using scope in this way, it is difficult to violate ownership.
However, the static relationship that scope implies is often not sufficient, at which time it is necessary to use pointers. When using pointers, you must manually implement ownership to avoid memory leaks, protection faults, and other nasty bugs. This requires careful use of the new and delete operators, and of constructors and destructors.
Java using scope with garbage collection
Java combines scope with garbage collection to avoid some of the memory bugs to which C++ pointers are prone. Java uses mark-and-sweep to destroy objects. At arbitrary intervals, program processing suspends and the garbage collection algorithm executes. First all objects are marked, then the network of objects starting from the root is swept clean. All objects left marked have no reference path from the root, and are therefore destroyed. At this point, program processing resumes.
Sign up for ITworld's Daily newsletter
Follow ITworld on Twitter @IT_world
jfruh
Apple syncing patent can't come soon enough
pasmith
New Twitter features borrow from 3rd party clients
Esther Schindler
Open Source Changes the Software Acquisition Process
mikelgan
How to set up continuous podcast play on the new iTunes
David Strom
Five important Windows 7 mobility features
sjvn
Guard your Wi-Fi for your own sake
Sandra Henry-Stocker
Grepping on Whole Words
Sidekick: The Good News & the Bad News
Either way you look at it Microsoft Data Center management did not follow standards or best practices in this failure. In which case it makes me wonder more about the outsourcing of corporate data much less personal data.
- mburton325
Join the conversation here
Quick, practical advice for IT pros. Made fresh daily.
Want to cash in on your IT savvy? Send your tip to tips@itworld.com. If we post it, we'll send you a $25 Amazon e-gift card.













