goran.hultgren at bluefish.se asks,
	[given copious memory]
	Save a document? Start a program? Reboot? A filesystem? ...why? :-) All
	programs can be kept running all the time etc. A document can simply
	"stay" in memory. Why change representation into a bucket of bits?
	
Yesterday I was trying to print some Postscript files.
(Fetch had very helpfully tagged them all as APPL instead of TEXT,
so I had to mess around with ResEdit; still haven't cleaned them all up.
First time Fetch has ever done that.)
Drag and drop a bunch of files onto MacGS, the first one prints OK,
then *freeze*!  I had to reboot the Mac several times.

Last week I was sent a .DOC file.  I wish people wouldn't do that.
I could view it OK in StarOffice, but it printed as white on white.
When I shipped it (as binary, what else?) over to the Mac, Microsoft Word
could display the file OK, but when I tried to print it, it was crash and
burn time.

Why do ciliates have two nuclei, a micronucleus and a macronucleus?
Because the DNA in the micronucleus is _stable_ for most of the lifecycle;
the macronucleus is a _working copy_ chopped up, rearranged, and subject
to all the ills that organic chemicals in active use are heir to.
In effect, the micronucleus is code out there in the file system,
while the macronucleus is code loaded into the OS and running.
The ciliates are a very successful group...

If programs never crashed, and never ever slowly corrupted their
internal data structures, there would be no point in restarting them.

If programs never crashed, and never ever slowly corrupted their
internal data structures, and if nobody ever wanted to move data
from one program to another, perhaps on a different machine, there
would be no point in externalising data in a stable form.

If nobody ever wanted to preserve versions of key data for archival,
normal recovery, disaster recovery, etc, then there would be not point
in saving files.

The ability to kill programs and restart them without (too much) data
loss and without rebooting the whole system is like the way democracy
lets you replace one lot of rulers with another lot, without a revolution,
without losing and rebuilding your food production and distribution, ...
Of course, what you get is just another program, still buggy, but that
just means the analogy's good:  what you get is just another set of
politicians.

	And of course Squeak as an OS gets even more interesting.  One
	of the questions we debated was the necessity of having a
	filesystem at all.  I argue that they may turn obsolete in their
	current form.

I think I heard _that_ one for the first time back in 1976.
It has arguably been done in Multics and KeyCos (spelling?).

	By "filesystem" I meant more or less a hierarchical namespace of
	bitchunks mostly only accessible locally on the host.
	
In that sense, filesystems have been obsolete since AFS, NFS, and RFS
were distributed, if not before.  MacOS has file sharing and has had for
quite a few years.  By that criterion, none of the UNIX or Mac boxes I
normally use has had a file system for the last 12 years or so.

	IMHO there is only one good reason for having "files" and that is
	because all the behaviour in the computer (OS, programs) have been
	written in a wide variety of languages and bitchunks are the only
	general form of data that "any and all" programs can handle.
	
No, there is a _far_ more important reason than that:
- it is easier to build a reliable (or at least recoverable) file system
  than to build a reliable general program.
The interface of and constraints on a file system are bounded, and there
is a _lot_ of accumulated knowledge about how to build them.  One of the
small mysteries of life is why Microsoft had such a flaky file system
(FAT) for so long when comparatively simple techniques for building much
more reliable file systems had been in the open literature for years.
But even the FAT file system was generally _recoverable_.

Here's one final example.  A couple of weeks ago I downloaded a Java
program.  It came as .class files and .java files.  Unfortunately,
the Java 1.2 'java' command didn't like the .class files.  If I only
had a snapshot of a running program, I would be totally unable to use
that program.  Fortunately, the .java files were there, and javac likes
them fine.  The micronucleus (.java) is more stable than the
macronucleus (.class) once again!