Nanofactories, controlled by computerized blueprints, will
be able to build a vast range of high performance products.
However, efficient product design will require advanced software.
Different kinds of products will require different approaches
to design.
Some, such as high-performance supercomputers and advanced
medical devices, will be packed with functionality and will
require large amounts of research and invention. For these
products, the hardest part of design will be knowing what
you want to build in the first place. The ability to build
test hardware rapidly and inexpensively will make it easier
to do the necessary research, but that is not the focus of
this essay.
There
are many products that we easily could imagine and that
a nanofactory easily could build if told exactly how. But
as any computer programmer knows, it's not easy to tell
a computer what you want it to do—it's more or less
like trying to direct a blind person to cook a meal in an
unfamiliar kitchen. One mistake, and the food is spilled
or the stove catches fire.
Computer
users have an easier time of it. To continue the analogy,
if the blind person had become familiar with the kitchen,
instructions could be given on the level of “Get
the onions from the left-hand vegetable drawer” rather
than “Move your hand two inches to your right... a
bit more... pull the handle... bend down and reach forward...
farther... open the drawer... feel the round things?” It
is the job of the programmer to write the low-level instructions
that create appliances from obstacles.
Another advantage of modern computers, from the user's point
of view, is their input devices. Instead of typing a number,
a user can simply move a mouse, and a relatively simple routine
can translate its motion into the desired number, and the
number into the desired operation such as moving a pointer
or a scroll bar.
Suppose I wanted to design a motorcycle. Today, I would
have to do engineering to determine stresses and strains,
and design a structure to support them. The engineering would
have to take into account the materials and fasteners, which
in turn would have to be designed for inexpensive assembly.
But these choices would limit the material properties, perhaps
requiring several iterations of design. And that's just for
the frame.
Next, I would have to choose components for a suspension
system, configure an engine, add an electrical system and
a braking system, and mount a fuel tank. Then, I would have
to design each element of the user interface, from the seat
to the handgrips to the lights behind the dials on the instrument
panel. Each thing the user would see or touch would have
to be made attractive, and simultaneously specified in a
way that could be molded or shaped. And each component would
have to stay out of the way of the others: the engine would
have to fit inside the frame, the fuel tank might have to
be molded to avoid the cylinder heads or the battery, and
the brake lines would have to be routed from the handlebars
and along the frame, adding expense to the manufacturing
process and complexity to the design process.
As I
described in lat month’s essay, most nanofactory-built
human-scale products will be mostly empty space due to the
awesomely high performance of both active and passive components.
It will not be necessary to worry much about keeping components
out of each other's way, because the components will be so
small that they can be put almost anywhere. This means that,
for example, the frame can be designed without worrying where
the motor will be, because the motor will be a few microns
of nanoscale motors lining the axles. Rather than routing
large hydraulic brake lines, it will be possible to run highly
redundant microscopic signal lines controlling the calipers—or
more likely, the regenerative braking functionality built
into the motors.
It will not be necessary to worry about design for manufacturability.
With a planar-assembly nanofactory, almost any shape can
be made as easily as any other, because the shapes are
made by adding sub-micron nanoblocks to selected locations
in a supported plane of the growing product. There will
be less constraint on form than there is in sand casting
of metals, and of course far more precision. This also
means that what is built can contain functional components
incorporated in the structure. Rather than building a frame
and mounting other pieces later, the frame can be built
with all components installed, forming a complete product.
This does require functional joints between nanoblocks,
but this is a small price to pay for such flexibility.
To specify
functionality of a product, in many cases it will be sufficient
to describe the desired functionality in the abstract without
worrying about its physical implementation. If every cubic
millimeter of the product contains a networked computer—which is quite possible, and may be the default—then
to send a signal from point A to point B requires no more
than specifying the points. Distributing energy or even transporting
materials may not require much more attention: a rapidly
rotating diamond shaft can transport more than a watt per
square micron, and would be small enough to route automatically
through almost any structure; pipes can be made significantly
smaller if they are configured with continually inverting
liners to reduce drag.
Thus, to design the acceleration and braking behavior of
the motorcycle, it might be enough to specify the desired
torque on the wheels as a function of speed, tire skidding,
and brake and throttle position. A spreadsheet-like interface
could calculate the necessary power and force for the motors,
and from that derive the necessary axle thickness. The battery
would be fairly massive, so the user would position it, but
might not have to worry about the motor-battery connection,
and certainly should not have to design the motor controller.
In order
to include high-functionality materials such as motor arrays
or stress-reporting materials, it would be necessary to
start with a library of well-characterized “virtual
materials” with standard functionality. This approach
could significantly reduce the functional density of the
virtual material compared to what would be possible with
a custom-designed solution, but this would be acceptable
for many applications, because functional density of nano-built
equipment may be anywhere from six to eighteen orders of
magnitude better than today's equipment. Virtual materials
could also be used to specify material properties such as
density and elasticity over a wide range, or implement active
materials that changed attributes such as color or shape
under software control.
Prototypes as well as consumer products could be heavily
instrumented, warning of unexpected operating conditions
such as excessive stress or wear on any part. Rather than
careful calculations to determine the tradeoff between weight
and strength, it might be better to build a first-guess model,
try it on increasingly rough roads at increasingly high speeds,
and measure rather than calculate the required strength.
Once some parameters had been determined, a new version
could be spreadsheeted and built in an hour or so
at low cost. It would be unnecessary to trade time
for money by doing careful calculations to minimize
the number of prototypes. Then, for a low-performance
application like a motorcycle, the final product
could be built ten times stronger than was thought
to be necessary without sacrificing much mass or
cost.
There are only a few sources of shape requirements. One
is geometrical:
round things roll, flat things stack, and triangles make
good trusses.
These shapes tend to be simple to specify, though some applications
like fluid handling can require intricate curves. The second
source of shape is compatibility with other shapes, as in
a piece that must fit snugly to another piece. These shapes
can frequently be input from existing databases or scanned
from an existing object. A third source of shape is user
preference. A look at the shapes of pen barrels, door handles,
and eyeglasses shows that users are pleased by some pretty
idiosyncratic shapes.
To input arbitrary shapes into the blueprint, it may be
useful to have some kind of interface that implements or
simulates a moldable material like clay or taffy. A blob
could simply be molded or stretched into a pleasing shape.
Another useful technique could be to present the designer
or user with several variations on a theme, let them select
the best one, and build new variations on that until a sufficiently
pleasing version is produced.
Although there is more to product design than the inputs
described here, this should give some flavor of how much
more convenient it could be with computer-controlled rapid
prototyping of complete products. Elegant computer-input
devices, pervasive instrumentation and signal processing,
virtual material libraries, inexpensive creation of one-off
spreadsheeted prototypes, and several other techniques could
make product design more like a combination of graphic arts
and computer programming than the complex, slow, and expensive
process it is today.
