It's a little annoying that Matt (or rather, Interconnected, it being a separate entity) is on autopilot right now, because I'm going to talk a little about his notes on cascading and recombinance and through that, tie together some threads that he's grouped together.
Here's some ideas and observations just to throw out there:
We all know that an object's utility increases pretty much exponentially according to the number of other objects that it can talk to. We know this because of the relationship between the number of edges and nodes we have in a graph (I've spent the whole bloody week thinking about graphs and edges and nodes for an assignment). We also know this because we like thinking about social software and nurturing rich connections amongst communities of people online and appreciate the benefits that inviting large numbers of people into a discussion can bring.
Let's take a view from one level - things that are in our world that aren't people: they're getting smarter and they're getting more interconnected. Of course, they're still incredibly stupid (compared to us), but what we've got now, that we didn't have before was a large array of relatively dumb things (still smarter than before, remember) that are just about starting to talk to each other.
We would have dumb things like, say, VCRs. VCRs don't really talk much, and one of the best innovations in VCRs were when they suddenly gained the ability to listen (they stayed mute, though), and in one fell swoop, every new VCR was spared the ignomy of sitting there with a blinking "12:00" light on its front. VCRs had learned (I'm terribly sorry, there'll be much more anthropomorphisation to come) to listen to the data that was coming in off television signals and set their clock themselves.
Witness the next step in VCRs: personal video recorders. This time, VCRs, or PVRs now, learned to listen slightly more (grab scheduling data over copper wire), but still aren't really talking. Note that PVRs grabbing scheduling data is more of an advance than the early Video+ system (until, of course, those VCRs started listening for broadcast flags that signaled when a particular program had started).
VCRs became less dumb, more useful and easier to use when their communication abilities increased. This is what it means to be part of a network, albeit in this case it was more of a push network, with no real interactivity.
That's great. We should have more objects that can listen, and maybe we should have more objects that can talk, too. Matt's take on Microsoft's Smart Objects idea, though, is that it's not enough to have a self-contained device that takes data in at one end and then squirts out a behaviour on the other. Note that I said the device will squirt out a behaviour: it's not entirely clear what the smart alarm clock will do other than wake you up early or let you know the traffic conditions when you get up.
One of the reasons why people like UNIX-like operating systems is that the have this principle of filters and pipes. With filters, you put something in, some magic happens, and then you get something different out. Pipes are simply a way of standardising how filters accept input and output. What you end up with is a whole bunch of utilities that take an input and produce an output, but they also accept input from pipes, and they can also output to pipes.
Thanks to all of these pipes and filters, it's suddenly a trivial task to string together a whole bunch of filters and feel like you've done something tremendously complicated in practically no time at all.
Small pieces, talking to one another.
Throw in some other parts of logic, some sequencing, repetition and choice and now you have an even more tremendously complicated thing that you've thrown together, without having to understand what it is that's going on underneath: all you need to know is that if you use program foo and give it a URL, it'll spit out a slightly altered one that you can pass to program bar.
This is, coincidentally, why a lot of people are falling over themselves to play with OS X, that bizarre operating system from Apple where not only do you get a yummy GUI (though certain UI elements aren't exactly fixed yet) you do get all the yummy bits of UNIX, namely all these pipes and various bits that you can hook up to each other. That's without going into the goodness that is the wonder Apple have built into the OS called Applescript, which even lets "normal" GUI programs talk to other programs.
You see the same kind of thing happening with object oriented programming, where you model real world problems with objects: objects have attributes (things that describe them) and methods (things that they can do). Take, for example, your car: it's red (an attribute) and it can move (a method). Here's the fun part: the objects talk to each other, because their methods can pass messages around. In fact, you get pretty much nothing done at all if you don't pass messages around, because all your objects will sit passively, not unlike a disinterested rock.
The problem with these filters and these objects is that most of the time, they don't tell you what it is exactly that they can do. There's no real equivalent for them where you send them a message and ask them what they can do where they respond with a nice message and say "Well, if you gave me x, I'd play with it for a while and give you y, how about that?"
This is where Matt chimes in: all these Smart Devices aren't smart enough, they're only half-fulfilling their potential if all they can do is suck in information and display it. If they can suck in information, display it and squirt it back out to whoever wants it, their utility increases manyfold.
In other words, imagine it like this. In a world where all objects (physical or abstract) are online and able to not only receive and send messages but to publicise what they do, creating novel applications becomes less of a chore and more like playing with Lego.
Let's explore this with the alarm clock example again--Microsoft's SPOT Alarm Clock will pull in assorted data off the network and adjust its display. However, it doesn't sound like it'll be able to do anything else (or, if it does, it may well be integrated into some sort of .NET service walled garden). On the other hand, let's try it with the send, receive and publish model:
You take your new clock home. Essentially, it's no more than a display with a simple processor behind it. When you take it home and power it up, it allocates itself a link-local IP address and joins your wireless network. Then, using a protocol like Rendezvous, it announces itself to the other devices in your network and lets them know what it can do. All the other devices on your network, your PVR, your fridge, your light switches, your television, your laptop, your PDA now know about your new alarm clock. At the same time, your alarm clock now knows about all of the above devices. So far, so hunky-dory, but this is where it gets interesting.
Your alarm clock displays the time. Your alarm clock is also connected, through your home's gateway, to the rest of the internet, so grabbing traffic reports is trivial. So far, so Microsoft Alarm Clock. But now, this alarm clock knows how to discover services on your home network so there'll be a button on your alarm clock that will say something like "What else can I do?" and pressing it will bring up a nice menu that will let you all the other activities the other devices in your home make available.
Fair enough, that might not be terribly interesting. But setting your alarm clock via your PVR's interface? Setting your alarm clock via your PDA? All these things become possible when devices are able to send and receive information and also make available what operations they can perform.
This is what Matt means when he's talking about cool things today ending in knots. The beauty about lego is that every bit knows how to connect to other bits. They have clearly defined interfaces (the knobbly bits and the indented bits) and, well, we can see them so we know what they do, so the analogy falls down somewhat there. The point is, though, that we can easily see what they do and how we can fit them together in new ways. There are only a few simple rules, but the combinations that can be produced--and can be produced quickly and easily, because that's the killer--are astounding.
It is an exciting time to be alive. This is a time where a company has finally been able to produce low-cost passive IDs for objects, where low-cost is under ten cents. Cover everything in IDs. Put smart dust everywhere, smart dust that can talk and will tell you what it can do and what it can see.
We started at the object level, examining the devices we use and how they're changing and we've slowly moved upwards: the next level is watching how we as people use those objects and how they help us create richer, more complicated, faster, more informationally dense relationships than before. There is an immense wealth of data out there that's being spontaneously generated sheerly through things being alive and acting, through things moving and interacting. Imagine a time and a place where all the time and every place was like bouncing off someone and coming up with new ideas that you could string together and implement in minutes.
2 comments and trackbacks