Fast, Cheap, and Small
We usually think of programming as making the system perfect beforehand rather than perfecting it in place. Consequently, computer programs are quite inflexible. If we could let our programs be more grounded in the real world, more open-ended, more independent, and more fallible---in other words, more like living systems---then they might eventually become quite competent at handling new problems. To do so, however, we'll probably have to make their parts small, fast, and cheap (that is, easy to make), and to do so we'll probably have to let them make mistakes from time to time, just as we do.
An intuition about something comes from remembering lots of little pieces of information that seem related to the current problem. But the relation isn't obvious, or it isn't easy to state, or it isn't always true, or we may not be consciously aware of it, yet it's true often enough that the intuition has value. Like a detective putting the pieces together, we come to it by consciously or unconsciously seeing lots of little things that add up to one big thing.
A computer program that deliberately makes mistakes sounds crazy, but suites of fallible yet fast, cheap, and small computer programs could help us find the truth by pooling many pieces of partial evidence---we might even call them intuitions. Each piece of evidence---each hunch---is useful, even if it may not settle the question at hand all by itself. If we're willing to give up some of our standard ideas about how computer programs must work then we might gain a lot of flexibility.
First, we can make an intuition-style computer program better simply by rerunning it. Of course, that would be senseless if the program always did the same thing. But if it varies what it does---even when the situation is the same---and if its average behavior is good, then we can reduce the chance that it blunders as much as we wish.
For example, our courts have on occasion jailed the innocent and freed the guilty. Ideally, the justice system should never err, but that's impossible in practice because knowledge is always incomplete. So to reduce the risk of being wrong we have appeals courts. Each successive trial is meant to be an independent test of the defendant's innocence. Of course, each trial really isn't independent---unless we can find aliens to be on the jury. But if each trial were independent, then after many of them we grow fairly confident about the defendant's guilt or innocence. Out of an inherently flawed process, we fashion a tolerably certain one.
Second, intuition-style programs could give us some idea of the truth much faster than the more normal massive programs that try to account for everything all at once. A partial answer that arrives on time is worth more than one with fifty digits accuracy that arrives a month late. Fast and crude is often better than slow and accurate.
For instance, Turing machines usually have the luxury of as much time as they want (as long as it isn't infinite time) before they have to respond. Not so for us. All living things have deadlines. We always have to make do. When playing tennis we can't stop the ball in flight and spend hours calculating the exact position and force to hit the ball to return the serve.
Third, if we have many intuition-style programs, all different, we can run all of them at the same time and let the answer with the most votes win. So with those kinds of programs, the more computers we can throw at a problem, the faster we might get an answer.
For instance: You're walking in Bengal, India. You spot a swiftly moving yellowish blur. You smell something rank. You hear a sort of coughing growl. You start running. Because you're about to be attacked by a Bengali tiger. Probably. No one of the things that your senses report to you, or that your knowledge of Bengal tells you, conclusively proves that. But putting them all together makes you almost sure. Besides, if you're wrong, you'll just have gotten some exercise. If you're right, you could be lunch. We make all our decisions the same way, whether we make in them in ten seconds or ten years, because we never have complete information about anything.
Fourth, if each intuition-style program is independent of the others, then many programmers can create several of them independently, without having to communicate with each other and so slow down the whole programming process. So with those kinds of programs, the more programmers we can throw at a problem, the faster we might get an answer.
For instance, while searching for a number with a certain property, one mathematician might report that the number is less than ten million. Using different methods, another might report that it must be divisible by fifteen. Using yet other methods, another might report that it's greater than nine million. Taken separately, each mathematician came up with a way to restrict the number only a little. Taken together, though, those pieces of information restrict the number quite a lot.
Fifth, intuition-style programs could be easier and faster for programmers to create. Each little piece---each intuition---only nibbles at the overall truth, so the complexity of each one is much lower than a giant program that tries to swallow the truth whole.
For instance, we get our news from many sources. We listen to the radio, watch television, read the paper, talk to friends, and so on. No single one of those news-gathering schemes tries to give us all the news there is. We don't spend a day in conversation, nor do we watch television all the time (well, most of us don't, anyway). If television broadcasters had to cover all the news there ever was, they would have no time to do anything else. Besides, they couldn't do it anyway---the task is far too complex.
Sixth, incrementally building solutions by adding more and more intuition-style programs lets our solutions be much richer and more responsive to change. If we gain some new and major insight into a problem, we need only add a new intuition-style program with high weight, so that the suite as a whole treats its guesses more seriously than those of the others in the suite. We needn't restart the whole problem-solving process from scratch the way we must do when we build large programs all of a piece. A suite of intuition-style programs could be easier for programmers to adapt to changing problems.
For example, we can move things around by car, truck, rail, plane, ship, or skateboard. Further, we have many words that once meant almost the same thing: dine, eat, feed, fare, devour, ingest, and so on. Different but overlapping things, whether they're transportation systems or words, are redundant and seem wasteful, but they compete with each other for business and so become more efficient at specialized things. Further, each one can take up some slack if a competitor fails. The system as a whole almost never fails entirely.
Seventh, programmers could let a suite of intuition-style programs develop a graduated response by letting some parts of the suite prepare the way for other parts. One small piece could be a scout for other pieces, each of which may take far more effort than the scout piece. The scouts can act as quick filters to determine which of the more complex (and slower) pieces should try their hand next.
For instance, television executives wishing to produce a new television show don't first spend all their money making the entire series. That would be too much of a risk. Instead, they take a little money and produce a pilot episode, incorporating elements of the show, and air that. If the public responds well, then they spend a little more money on a few episodes. If the public likes that, then they commit a lot more money to a run of shows, and so on. Similarly, we don't necessarily marry the first person we meet. We usually meet many people briefly and progressively divert more and more time to those who were most agreeable on the last pass. Or yet again, military forces don't usually attack all at once, they attack in stages, committing more and more resources to areas where the enemy has already seemed to be weakest.
Eighth, programmers could let a suite of intuition-style programs adapt itself---at least part of the time. If its decisions are influenced by the significance the suite as a whole gives to the partial answers given by each of its parts, then over time the suite could attend more to those parts that have most often guessed right in the past.
For instance, we give value to those who've been successful in the past. A bestselling author has a higher chance of getting a new book published than an unknown author. A television show we know to be amusing is more likely to get our attention than one we know to be boring. A successful movie spawns imitations, variations, and sequels. (Of course, that isn't necessarily a formula for high creativity.)
Finally, programmers could let a suite of intuition-style programs copy successful parts of itself and change them slightly, hoping for even better performance next time. Or it could copy parts of two or more independent pieces and recombine them to form new pieces---machine sex. We now have the bare beginnings of a self-evolving programming system.
This is only a start, however. We must also make the parts assume things about the universe they live in. They must assume that the universe possesses well-known regularities and they must stick to those assumptions for a very long time until absolutely forced to give them up. Only then are they allowed to cry for help from their user.
Second, the parts must live in a market economy: they must be used based on their cost. The system as a whole must assume that the cheapest solution is the best solution not necessarily because it is, but because it's the only one that can be found in a reasonable time. The system must be allowed to evolve.