When you want to get one computer to talk to another one, both computers must know the same rigid set of rules. These rules are agreed upon standards that are shepherded by an organization called The Internet Engineering Task Force, which publishes these standards through a very detailed and well-documented process.
The specifications for the standards are published through documents with a very friendly sounding name — “Requests for Comment” (more commonly known as RFCs). However, a quick perusal through even the first RFC (RFC 0001 from April 7, 1969) will show you that right from the start, these rules have always been quite complex, intricate, arcane and inflexible.
Note: if you work with computers and find RFCs to be insanely boring, don’t worry you’re not alone. However, if you don’t work with computers and you find them to be a fascinating read, you truly missed your calling.
All of this complicated, structured interaction between computers is designed with good reason. Computers, despite how quickly they can perform calculations, are pretty stupid. They need clearly defined rules of engagement. As as result, however, we get an either/or kind of performance. Either both systems know exactly how to talk to each other precisely along these rules, or they don’t. It will either work or it won’t. There isn’t a lot of in-between.
Take network protocols, for example. Protocols, in short, are agreed upon patterns of conversation between computers. For example, when e-mail is sent from one server to another, the servers communicate using the SMTP protocol. The protocol is very rigid in the structure. Both sender and receiver must communicate in a pre-orchestrated conversation that, in English would look something like:
Server 1: Hi, I’m an e-mail server.
Server 2: Hi, I’m the e-mail server for davekawalec.com.
Server 1: OK, what do you got for me?
Server 2: I have an e-mail from blog@davekawalec.com.
Server 1: OK.
Server 2: This e-mail should be delivered to whoever@phonydomain.com.
Server 1: OK.
Server 2: I’d like to start telling you the contents of this e-mail.
Server 1: I’m ready. Go ahead.
And it goes on and on like this. If either of the two servers doesn’t communicate the correct information in the correct sequence, the whole transaction is a failure. Even if Server 1 doesn’t say, “OK” in all the right spots, Server 2 will just stand there tapping its foot until the either it gets the “OK” it wants, or it just gives up and times out the session.
What if people operated this way? What if there was no variance allowed in the protocols we use to speak with one another? Imagine two co-workers at the office, we’ll call them Sally and Phil, walking toward each other down a hallway. Let’s say the RFC says the initiator of conversation should say, “Hello” but instead, Sally says, “Hey, Phil”. Without a flexible protocol (a combination of language and social norms), Phil would have no idea what Sally was getting at. The two would pass right by one another, maybe with each wondering why the other was being so rude.
Actually, given the strict rigidity of computer protocols, a successful standards-driven conversation between Phil and Sally might go something like this:
Sally: Hello, I am Sally what’s your name?
Phil: Hello Sally, my name is Phil.
Sally: Hello, Phil. I would like to begin having a conversation with you.
Phil: I agree to begin having a conversation with you.
Sally: Thank you for acknowledging me.
Phil: I acknowledge that you thanked me. I am waiting for you to ask a question.
Sally: How are you?
Phil: I am fine.
Sally: I have acknowledged that you are fine.
Phil: I am waiting for you to ask a question.
Sally: I don’t have another question. We can stop talking now.
Phil: Goodbye.
This kind of thinking pervades computer design from top to bottom. When I create a database, the first thing I have to do is to create a structure to put my data in. I have to not only know what kind of data I’m going to use, but I have to already know how that data is going to interrelate. You can’t start a database as a neutral “knowledge bucket” and let the database organize and relate the data on its own as those linkages become evident over time. You create a field, and you have to tell the database whether that’s going to hold a little text, a lot of text, smaller numbers, big numbers, dates/times, true/false … whatever. And that field is what it is always and forever. If you want to interact with the database, you must organize your data that way and package it in a way that the database can agree is correct.
This approach has been enormously successful up until now. However, is there a better way that computers can be designed to function to put some slack in the rigid rules? Can computers be designed to operate without such strictness, more along the lines of how people casually communicate?
Certainly, I’m talking about some level of artificial intelligence, because in order to accomplish something like this, computers would have to be capable of discerning meaning and intention outside of a set framework of expectation. There is great work currently being done in the field of artificial intelligence, neural networks, and such. For me, it’s exciting stuff to read about. However, I’ve noticed that the approach is typically to write the intelligence into a software abstraction. So, even if successful, we would be left not with intelligence, but with a simulation of intelligence.
What if instead of working on just 0s and 1s, computers could be made to understand, at a very low level, the infinitude of decimals in between?
{ 1 trackback }
{ 0 comments… add one now }