From: Andrei Alexandrescu (andrei@cs.washington.edu)
Date: Wed Jan 15 2003 - 22:28:41 PST
Hi all,
Hope you enjoy your conference. This message might sound totally off-key
viewed from the context you guys are in, but maybe we can chat about it
sometime later.
Just read an article that confirms some conviction that I've had for a long
time:
http://www.eclipse.org/articles/swt-design-2/swt-design-2.html
In essence, the article witnesses that garbage collection is not general
enough to cope with all kinds of resources, and tells what solution the SWT
authors came up with. Unsurprisingly, the solution is... to go back to
manual cleanup of resources the garbage collector doesn't have control of.
So, it seems like after all the progress, it's still turtles, I mean,
C-style, all the way down. What gives?
Garbage collection addresses memory very nicely, but memory is just one of
many resources in applications out there: database connection pools,
OS-related stuff (such as the graphical resources the article talks about),
files, network connections, sockets, interprocess synchronization objects,
and so on. For those, a language without deterministic termination
mechanisms (or, more generally, some form of automatic invocation of
functions) lets you with the only option of tediously doing things by hand.
Garbage collection is a great tool for writing large, serious applications.
At the same time, deterministic termination seems to be a very useful tool
as well. So why wouldn't a natural solution include both?
Some people who are in favor of garbage collection mention dangling
pointers as a problem. In doing so, they collapse together two distinct
stages in destroying an object - (1) cleaning up whatever resources that
object might have allocated, and (2) releasing the memory occupied by the
object itself.
However, if a language offers guarantees that a function is automatically
called upon exiting an object's scope, but leave the memory occupied by the
object itself to be garbage collected, it seems like we get the best of
both worlds: programmers get a crack at releasing non-memory resources, and
there are no dangling pointers because the "shell" of the object is still
there in memory.
It seems like there's a tendency towards combining the two: C# recognizes
an IDisposable interface, in conjunction with a 'using' statement (that
looks syntactically horrible in my opinion). See
http://www.jaggersoft.com/csharp_standard/15.13.htm. Anyway - if you use
'using', the system will automatically call Dispose() for you when your
variable goes out of scope.
Would be nice to further look into ways of reconciling garbage collection
and deterministic termination. Aspects might come into play (maybe one can
define an aspect, "when an object exits its syntactic scope"?) Seeing the
two as competing is, I think, a mistake; there's a lot of complementarity.
I'd love to discuss this further.
Andrei
_______________________________________________
Cecil mailing list
Cecil@cs.washington.edu
http://mailman.cs.washington.edu/mailman/listinfo/cecil
This archive was generated by hypermail 2.1.5 : Wed Jan 15 2003 - 22:34:37 PST