Relaxing your requirements reduces cost. This is a basic principle of engineering. (It may also show up as "increases your reliability / something else desirable at the same cost".)

It sounds from the article like they were previously doing enough maintenance, design work, and fiddling around to keep the frequency at 60.000 +/- 0.001 Hz, and now they've decided they only need to keep it within 60.000 +/- 0.010 Hz . Those aren't the correct numbers (I couldn't find them in any of the articles), but that's the idea. They're going to worry less about the exact frequency, because it makes the system cheaper to run, and nothing cares except 1980's VCR clocks.

I've been away from cutting-edge technology for a while (poor graduate student), so I had to look up whether microSD cards are compatible enough to be useful here.

SD cards are a type of memory card that come in three basic sizes: SD cards, miniSD, and microSD. The microSD cards are indeed ridiculously tiny, and can fit in a hollow coin. Many computers today (particularly laptops) do come with integrated SD readers, but they can't fit the microSD cards without an adapter (microSD in a normal SD slot) or a USB reader.

So you can carry around a liveboot linux distribution in your "lucky half-dollar", full of awesome spy tools, but it won't work on most computers unless you're also carrying around a microSD reader. So you're a lot better off buying one of the tiny or pre-disguised USB drives (pen, cigarette lighter, etc.). ThinkGeek has plenty.

As a comp sci grad student, here's what I got from a quick reading of this paper:

Imagine that you're a content provider, with paying users. You've decided to distribute content to your users by running a Gnutella-style network. How do we make sure that only paying users can get our content? After all, it's an open network.

We start by sending some sort of magic timestamp-thing to all of the paying users. I didn't read this part in much detail. Anyway, the paying users can all identify each other somehow. They mention that it maintains privacy.

Some of your paying users (the "Clients") are good, virtuous folk, and they're running the Happy Authorized Gnutella software you gave them. Others (the "Colluders") are running Evil Hacked software. No matter what you do, the Colluders are going to send chunks of your precious data to the "Pirates" (anyone who hasn't paid you).

Normally, we'd expect our Clients to ignore requests from our Pirates. This paper instead suggests: let's obligate the Clients to send poison data to the Pirates! The Pirates won't know which chunks are bad; they'll only find out that the file is corrupt once it's finished downloading. The Pirates won't be able to get a good copy, and they'll give up and go away.

And there's one other great thing: we can set up *fake* Pirates, and check which users aren't giving out the poison they're supposed to! So we've served data to all of the Clients; we've identified all of the Colluders; and we've defeated all of the Pirates.

(Bittorrent has data integrity checks for every chunk, instead of every file; that's why it's not vulnerable to this attack...I mean business model).

In summary: This paper describes a way that a company can charge for distributing their own content on a peer-to-peer network. It only works if they control a centralized "transaction server" thThat's why no one has ever at organizes the entire network, and if they control the software of all the "honest" people. They can't destroy our existing networks with it, and it doesn't prevent anyone from turning around and posting the file to BitTorrent once it's downloaded.

The tone of the paper is definitely not as neutral as I feel it should be. What they're trying to say is "there's no obvious way to charge people for running a Gnutella server, because pirates will eat your lunch. But we think we have a way." But it definitely feels like they're putting moral force behind what's really a network algorithms result.

In seriousness: the one-bit half-adder. It adds two bits, generating an answer and a carry.

This is the simple machine for a tiny bit of idealized computation.