Our products become more and more complex. Compare a Ford Model T and the latest Ford car. While the cars are essentially the same - both have four wheels, an engine, both drive on roads - the "complexity per kilogram" has dramatically increased. The new car has sensors aplenty in almost every part of it, small chips controlling everything from how gasoline burns to how the airbags should be deployed. The same increase in complexity is apparent everywhere.

This increased complexity, however, leads to design complications. CAD tools have alleviated the problem to a small degree, but they will not be sufficient in the future. Bugs are the result of our inability to forsee the side-effects of our choices and the interplay between different components.

"When you want to place a billion transistors, the design tools don't work any more." [1] Companies that develop new chips, Internet, power grids and airplanes can't have complete understanding of what they want to make anymore.

This is a challenge for physical products, but the problem is much more pronounced in the realm of software development, where increased complexity have been a problem since the 1960's (see Wikipedia:Software_crisis, and the history text of Wikipedia:Software_component). Work is underway in making it possible to quickly design complex but reliable and bug-free software systems. This will probably be commonly used in 10-20 years. We anticipate artificial intelligences that are capable and entrusted to write software. But the question remains: "What will it look like?"

Some approaches to solving complexity problems follow:

  • Abstraction, abstraction, abstraction: As it is now, just carried on. Current work in this field: the development of software components. Software components are like little mini-servers that are transferable, sleepable, configurable, introspectable, and can communicate with other components, in a number of different ways. Component systems meet the holy grail of computer software reuse.
  • Declarative programming: Instead of designing systems of software, declare what the system is supposed to be able to do, and declare what the system is supposed not to do. Have a computer figure out what you mean, what its capabilities are, and how to wire them together. Abstract declarative systems include tuple-space and prolog, though declarative programming stretches far beyond these two examples.
  • Genetic programming: A subset of declarative programming, where the capabilities and instructions to use them are encoded in virtual "genes", and distributed simulations of the program host environments are run, over and over, and scored to find an optimal solution. The declarations are worked into the scoring system.

Genetic algorithms have already been used successfully to create walking algorithms for a dynamically reconfigurable robot, M-Tran.

A nanofactory (or a nanoassembler) would probably be the culmination of complexity, being in a sense, a seed from which everything possible can emerge. A computational counterpart is the Seed AI.


  • Lion Kimbro wrote a lot about the future of software development in a timeline he wrote in 2004.