If you burn it, it is.

Doubtful - the single digit users were the original cast of editors... who I haven't seen post a comment (unless it was a meta-slashdot story) for years.

Did somebody make a sound?

It's steganography, not stenography. Stenography is what people in court-houses do.

Hmm. To the byte?

I very rarely find any similarly sized files that large, and those that I do, there are usually only two of them. Usually, these are videos, or audio files that I've copied/rsynced around in such a way that they ended up in two places.
Of course, everyone's usage will be unique, but I can't imagine finding that scenario being common.

Ask, and ye shall receive.

Let me know how it goes for you. Especially if you're not on Linux, as I've only tried it on Linux, and I'm not sure how the symlink detection works on other OSes.

You need to compile the .java files to .class files.

You'll need something called javac (which comes with the Java Development Kit (JDK)).
It's not super easy getting the hang of it at first.

Clone the git repo, run mvn clean install (you'll need to download Maven), and then you should end up with a JAR file. Then run java -jar finddups.jar and things should start to happen.

Or should I just commit a JAR file to Github?

Yes, that's something I thought about. It's a trade off, isn't it? If you have two 700MB files that are both the exact same size, but are different, the way I'm doing it is quickest. If the two 700MB files are the same, then it will probably be about the same time as CRC/MD5ing the files.

If you have many small files, then I guess the IO won't be that much anyway.
My implementation offers a parameter to ignore files smaller than a specific size, which is how I run it: java -jar finddups.jar /path 200000 (for instance).

Another commenter to your comment suggested doing it adaptively, which would be easy.

Exactly. What I do is this:

1. Compare filesizes.
2. When there are multiple files with the same size, start diffing them. I don't read the whole file to compute a checksum - that's inefficient with large files. I simply read the two files byte by byte, and compare - that way, I can quit checking as soon as I hit the first different byte.

Source is at https://github.com/caluml/finddups - it needs some tidying up, but it works pretty well.

git clone, and then mvn clean install.

But you've less chance of ending up in a fiery car accident after sliding off the road on black ice.

You are wrong. There is a fine-grained security manager that can limit most stuff.

http://docs.oracle.com/javase/1.4.2/docs/guide/security/PolicyFiles.html
and http://docs.oracle.com/javase/1.4.2/docs/guide/security/permissions.html

Sounds great.

Now, how can I be sure that the Javascript executing in my browser, a:. isn't malicious, and b:, hasn't been intercepted and changed by someone in the middle?

"Who is first language isn't Mandarin?"

Do you mean whose?

Assuming that the DNS for the IP address range is delegated to the admin first of all.

It's all very well setting up rDNS, but sometimes, the bureaucratic nightmare to get the range pointed at your DNS server is just not worth it.

What are you talking about datacentres for?