Comment on The Sticker Network

BenRayfield Tue, Aug 24, 2010
Olena, what kind of designing can you do?

The first thing we would need is somebody to build a few wireless network routers and test them as a chain between 2 computers in the simplest possible way: sending 1 bit at a time.

After we know we can do the simplest thing, start making improvements like making it solar powered, small enough to fit on a sticker, ok to get rained on when stuck on something outside, bigger range, more efficient power usage, and most importantly invent some new algorithms to make it work in a peer-to-peer way and test that. We need hardware people first. I can design some of the software for it (maybe to be embedded as part of the hardware).

This can be done easiest in Linux because the core of Linux is open-source (and some versions, like gNewSense Linux, are completely open-source), so we don't have to deal with any businesses. If we get stuck on how to build hardware without any patents or businesses, see how  did it.

Addresses: Most of the internet today uses  and lots of complex protocols built on top of that, but we don't need any of that in the stickers. We simply need 1 way to give a label (an address) to each sticker, and a separate device to do the complex IP4 stuff and other stuff for compatibility with the existing internet. We can build a much simpler way to do addresses in our peer-to-peer network, and only translate it to the complex stuff in the devices people connect to their computers which access our network and the normal internet. IP4 uses 48 bit addresses (32 bits for IP address and 16 bits for port). IP6 uses 128 bit addresses. I think The Sticker Network should use variable size addresses. The first part should be a 16 bit number that tells the size of the address, so we can have addresses anywhere between 17 and 65536 (2^16) bits, counting the first 16 bits that tell the size of the address number as part of the address number. A 17 bit address would be "0000 0000 0001 0001 0" or "0000 0000 0001 0001 1" because 10001 is 17 and they each have 17 digits. Since the first 16 digits always tell the total size of the address, a 17 bit address can only cover a network of 2 computers, so most addresses will be bigger. I want to allow addresses up to 65536 bits (instead of 48 for IP4 or 128 for IP6) so we can add some intelligence into the address, like a small algorithm that defines which path it should take depending on what the current Sticker is doing. Theres lots of possibilities when you allow variable size addresses, and its easy to start doing because you can start with 19 bit addresses (for example) for a network of up to 8 (2^(19-16)) computers and stickers.

A sticker has to be a little like a computer, so we want it to be the simplest and cheapest kind of computer, and that is a Lisp Machine. Of course we can't use that particular kind of computer, but I think The Sticker Network should support the most important and simplest parts of the Lisp programming language because its very flexible and almost the simplest language possible. All simpler languages are so hard to use for practical things that they're only used in programming competitions and things like that. A hardware that runs Lisp can be built very cheaply and simply, and can be reprogrammed when we create the next version of the network router software. Each sticker in The Sticker Network should be a programmable Lisp computer, and still cost only a few dollars. How much does a 10 megahertz (not gigahertz) CPU cost? Not much more than the silicon its printed on. They don't have to be fast or have a lot of memory. They just have to work in a very simple way. A few dollars per sticker can be done.

When I say Lisp, I mean the most pure form of it, before it got merged with non-Lisp languages that have things like integers, floating-point numbers, and other optimizations. I think The Sticker Network should be a much simpler hardware than that which runs pure Lambda Calculus. If you want a multiply function, build your numbers from bits, and define the multiply function as a Lambda function on 2 sequences of bits. Lambda is the core of Lisp, and we should not complicate The Sticker Network by adding anything that can be derived from simpler things.

Whoever works on this should keep good records of what they do, including videos and grids of numbers and writing about what the numbers mean. If this is going to happen, we can't have people thinking we're making it up. We need to make progress and prove it.