We have used the tie facility in two ways. One is to give an existing package an easy frontend (as Perl does for DBM files); another is to monitor an existing variable. Let us examine what the other languages have to offer in these contexts.
Tcl provides a command called trace to trap read and write accesses to scalars and associative arrays. (Scalars and lists are interchangeable, so there's no separate facility for the latter.) The Tk toolkit puts tracing to good use, as we shall soon see in Section 14.1, "Introduction to GUIs, Tk, and Perl/Tk". trace doesn't occlude the previous value, so writing a monitoring package is simpler.
Tcl's C API allows you to create traces much more easily than is possible with Perl. (Actually, this ease of use factor is true of the rest of the Tcl API also, as we shall see in Chapter 20, Perl Internals.)
While an existing Tcl package can use this facility to provide an easy frontend for a package, I'm not aware of any that take advantage of it, as Perl does for DBM files.
Python allows you to write special functions per class called __getattr__ and __setattr __ that allow you to trap accesses to member attributes (or simulate new attributes). Similarly, you can make a class simulate an array by providing special methods called __getitem__ and __setitem__. There are 40 such methods to overload all kinds of behavior.
C++ does not allow dynamic traces to be put on a variable. On the other hand, it does provide an extensive set of operators and operator-overloading syntactic structures to allow you to substitute an object where fundamental data types or other objects are used.
Commercial tools and libraries such as Purify are capable of setting a dynamic trace on any region of memory. They also provide a C API to write your own callbacks on such an event.
Java does not allow you to arbitrarily trap accesses. Some commercial transaction- processing systems go to the extent of looking at the byte-code to recognize accesses to member attributes and insert traces where necessary. This allows them to make any object transactional without the explicit cooperation of the object. This approach is clearly not for the faint of heart!
Java does not have any way to implement the other aspect either: making a class appear as an ordinary variable.