PLEASE READ THIS

Week of April 16, 2002

Hey Mr Microsoft,

Sorry for the spammy subject line, but I had to make sure this 
letter got through and wasn't waylaid by one of your marketing 
execs. I want you and you alone to see this letter, Mr Microsoft.

I've been doing some research since last I wrote. I just completed a 
mail-order course in Visual Basic and I think I am about ready to 
start writing some cool tight apps. Also, I took two weeks to learn 
the Windows API. It's good to know the Windows API.

But anyway, I send these ideas to you, because your company is the 
leading technological developer on the planet, and because you need 
help innovating, after all that trouble you had in (the other) 
Washington. Anyway, here they are.

One Computer One Root
---------------------
I have been thinking about this a long time, and I think it's my 
best idea. I mean, what do people in China do? Do they have drives 
A: and C: and so forth, just like us? But they don't use our 
alphabet, do they? They have their own alphabet, right? So how does 
it feel to have our drive letters? Not good I bet.

There is an easy way out of this. I am surprised you guys haven't 
thought of it by now, but if you act quickly you can still get 
credit for the good idea.

What you do is you make a single root directory for every computer. 
Then you make a sub-directory under root for example, that you call 
'Floppy', and you 'mount' the floppy drive A: under this directory. 
Your root directory is your C: drive, and if you have other drives, 
then you 'mount' them under the root too.

And while we're at it - do we really need this horrid backslash? I 
hate the backslash - it's so hard to get at on my computer. Can't we 
use the forward slash instead?

PMOC
----
When I run your COMP program, it often says 'Ten or more differences 
- aborting' and that does me no good. I often want to know about the 
ends of the files, if they're the same or not. So I was thinking, 
couldn't you write a program called 'PMOC' (that's 'COMP' backwards) 
which compares files from the end instead?

Nobody can do this yet, Mr Microsoft - you can be First in the 
World.

To Run or Not to Run?
---------------------
Sometimes we have programs that can run but we don't want them to. 
But we can double click on them by mistake and then we crash our 
computers. That isn't good. So we have to rename the files to stop 
them running when we click on them by accident. But that isn't good 
either, as maybe we can't remember the original file name after a 
while?

OK. So why not have a file attribute 'X' which stands for 'eXecute'? 
So only if this attribute is set can the file run?

And sometimes we want to exclude directories from searches, and if 
we could use this 'X' bit on directories too, the 'X' would mean 
'you can run this directory', that is, you can 'eXecute' this 
directory, and if the 'X' bit isn't set, then you can't list it and 
your directory is exempt from the search? So then we could use the 
'X' on both program files and directories too.

And your file attributes right now allow you to read files but not 
necessarily to write them, but never the other way around? Look at 
it this way: Say we have this application, the users have to send 
data to its files, but this data has to be hidden, so they can send 
their data, but they're never allowed to see ALL the data as a 
whole, because that would be INVASION OF PRIVACY we can say, so they 
can only write, not read?

Can you do this too? Right now you have 'R' which stands for 
'Read-Only' but the 'R' looks more like 'Read', and anyone can do 
that, but you don't have a 'W' for 'Write', do you?

So use them both. And if you don't have a 'R' then you can't read a 
file, and if you don't have a 'W' you can't write it.

As far as I know, there is no other company which has this idea 
either, so once again Mr Microsoft - step on it!

Virtual Memory
--------------
Sometimes you need a program to run faster than others, and the 
normal time slicing is not good enough. So if we could ourselves set 
a file attribute bit so the program stays in memory more often...

Again, Mr Microsoft, I think if you act now, you can still be 
first...

Contiguous Directories
----------------------
When directories need to expand on disk, they fragment the disk free 
space, so my suggestion here is that you use less information in the 
directory itself.

Like today you have the file name, then the extension, then the file 
attributes, then the three times, then the starting cluster - take 
all that out.

Have a single file on every physical drive with all this information 
in a big long list - call it the INDEX LIST FILE, or 'ifile' for 
short. The ifile will be easy to read and maintain too - just think 
about it.

Then instead of the directory information, all you have is the file 
name and the INDEX into the ifile - that's it!

Oh - by the way - have you understood the implications here? Because 
the file name is not directly tied to the physical file information 
but to an INTERMEDIATE NUMBER (an index), ANY FILE WITH THE SAME 
INDEX WILL IN EFFECT BE THE SAME FILE - even with a different name, 
and even if the file is in a different directory!

This will of course not work on different physical drives, but still 
and all.

There is a caveat too, you guys might have found it sooner or later, 
I don't know, but when you delete a file, you don't actually delete 
the file itself, you destroy the link to the ifile. Then when you 
don't have any more links to the ifile, you delete the file and free 
its index in the list.

This could be *very* cool, as you could traverse from one side of 
the known universe to the other with a single 'chdir' command, just 
like Picard does with his Beamer.

So the directories themselves would be a lot smaller, so they 
wouldn't fragment disk free space as often, so the computers should 
run faster on an average too.

Well that's my ideas. I hope you like them. You don't have to give 
me money for them, I know you wouldn't give me any anyway, just give 
me a little credit, ok? Maybe Microsoft Classic Board Games?

Bye.