Mech. Mach. Theory Vol. 25, No. 3, pp. 365-381, 1990 0094-114X/90 $3.00 + 0.

00
Printed in Great Britain. All rights reserved Copyright © 1990 Pergamon Press plc

A METHODOLOGY AND COMPUTATIONAL

F R A M E W O R K FOR C O N C U R R E N T PRODUCT
A N D PROCESS DESIGN

M A R K R. CUTKOSKY t and JAY M. TENENBAUM 2

~Meehanical Engineering Department, Stanford University, Stanford, CA 94305-4021 and
2Schlumberger Palo Alto Research, 3340 HillviewAvenue, Palo Alto, CA 94304, U.S.A.
Abmract--We describea methodologyfor Concurrent Product and ProcessDesign and a computational
framework that supports it. The methodologyis based on the premise that manufacturability is best
assured by simultaneouslydesigning a part or assemblyand the processused to fabricate it. The designer
works in "manufacturing modes", adding features to the design or manipulating the processplan itself.
The computational frameworkto support this methodologyis inspired by human team designand consists
of cooperating experts (human and computational) that critique and refine a design from multiple
perspectives (e.g. tooling, fixturing, path planning, materials).

1. I N T R O D U C T I O N
It is now widely recognized that bridging the gap between design and manufacturing is essential
for improving product quality and reducing the time to market. Today, design and manufacturing
proceed sequentially, coupled through annotated engineering drawings. The problems with this
style of operation are well-known. Designers often do not anticipate the manufacturing impli-
cations of their decisions and manufacturing engineers produce designs in a way that violates the
designer's intent. Occasionally, manufacturing engineers will "fix" inconsistent tolerances on a
drawing and produce a prototype that functions, but is not to specification. The design office never
learns of the change so that eventually, an order is placed for several hundred items that are
impractical to produce [1].
Even when such errors do not occur, the system is inefficient since manufacturing engineers must,
in effect, re-enter the design in the form of a process plan. The inefficiency is compounded for large
projects where different groups of people design and manufacture the various components of a
design. Since each department makes choices based on local criteria, the design is globally
sub-optimal. The consequences of these communication problems are lengthy design cycles, costly
design iterations and, ultimately, products that fail in the marketplace.
The advent of computer-aided design and flexible, automated manufacturing has brought
improvements in productivity but, if anything, it has further removed the designer from the
manufacturing process. There is no longer a friendly machinist or welder to suggest refinements
to the design and provide feedback during construction of a prototype. Moreover, because most
computer-aided design systems neither present manufacturing information to the designer nor
capture process-related decisions by the designer, CAD/CAM integration is difficult to achieve.
In response to these problems, design for manufacturability has become an issue of importance
both in academia and in industry, and a number of tools and methodologies have been proposed
to ensure that manufacturing concerns are addressed at design time. Three of the most promising
methodologies are simultaneous engineering, team design and rapid prototyping.
Simultaneous engineering stresses consideration of life-cycle concerns such as manufacturing,
reliability and maintainability early in the design of a product. Designers need tools that can help
them assess the economic consequences of design tradeoffs (e.g. tradeoffs among manufacturing
costs, parts availability, and reliability as they affect maintenance). Perhaps the best known
examples of a simultaneous engineering tool are the design for assembly analyses of Boothroyd
and Dewhurst [2]. While useful in many applications, such tools have the drawback that they
evaluate existing designs instead of helping the designer to explore new possibilities. Also, designers
complain that they are tedious to use.
Team design brings together, in one location, specialists from various departments so they can
work together on the design of a product and the processes used to manufacture and support it.

MM=r25/3---I 365
366 MARKR. CUTKOSKYand JAYM. TENENBAUM

For modestly sized projects, this approach can significantly improve design quality and speed [3].
Unfortunately, experienced specialists are in short supply and it may not be practical to put them
in continual contact with designers. Moreover, team design does not scale well to large projects
(e.g. aircraft), which involve hundreds of engineers and subcontractors at geographically dispersed
sites. Finally, the people on any design team are subject to human limitations; they may forget
things or gloss over a detail, and however experienced they may be, they do not represent the
complete corporate knowledge that could be brought to bear on a problem. Thus, we need tools
that can support a "distributed team" linking members from different organizations and locations.
Rapid prototyping is a methodology that advocates short development cycles. The rationale,
familiar from software engineering, is that anticipating every design and manufacturing problem
is impractical. Rather, the fastest and most effective way to converge on a successful product is
rapidly to iterate through a number of complete product cycles. One way to accelerate prototyping
is to do much of it on a computer. An ideal environment for computational prototyping will permit
modeling and simulation of the design, manufacture, and operation of a product. These same
capabilities are, of course, also valuable for supporting simultaneous engineering. Ultimately, a
physical prototype must be fabricated, so tools are also needed to link design and manufacturing
(e.g. process planning tools, and tools that that make designers aware of the capabilities of
manufacturing systems).
In summary, simultaneous engineering, team design and rapid prototyping are promising
methodologies but today's CAD/CAM tools do little to support them.
In this paper, we discuss Concurrent Product and Process Design, a direct approach to bridging
the gap between design and manufacturing that combines the best attributes of simultaneous
engineering, team design and rapid prototyping. We assert that constructing manufacturing plans
after the fact (i.e. after the specified function of the design has been translated to form) is both
hard to do and likely to give suboptimal results from a manufacturing standpoint. Instead, we keep
the designer continually in touch with manufacturing processes by providing "manufacturing
modes" that capture process characteristics at an abstract level. Working in manufacturing modes
is similar to feature-based CAD, except that features are promptly translated into process plans.
Alternatively, the designer can directly edit the process plan or work with operations that capture
the "feel" of processes, for example, forming a sheet of plastic or snapping parts of an assembly
together.
First-Cut is a rapid-prototyping system that implements the above methodology. First-Cut's
CAD screen provides the designer with windows providing views of the design, menus of legal
operations and a graphical programming language for describing process plans. Prototype parts
can be produced at any stage of the design. The architecture of First-Cut is, in essence, a team
of specialists that cooperate in building and analyzing engineering models. We are extending
First-Cut toward a framework for "virtual" team design, in which human and computer experts
(possibly in geographically dispersed locations) cooperate to solve engineering problems.
In the following sections we focus on the methodology of concurrent product and process design,
extending previous work reported in Refs [4, 5]. In a companion paper [6], we address the
underlying computer science, representation and modeling research issues. In Section 2 we describe
First-Cut and provide an extended design example. In Section 3 we discuss the underlying design
representation that makes First-Cut possible. We then discuss ongoing work to increase First-Cut's
competence for machining and assembly, and extensions toward a more general computer-aided
environment for concurrent product and process design. In Section 5 we expand on the design
philosophy embodied in First-Cut and, drawing on our experience with the system, we examine
concurrent design in the context of other design styles such as feature-based, constraint-based and
functional design.

2. F I R S T - C U T : OVERVIEW AND EXAMPLE

To focus our exploration of concurrent design we constructed a limited end-to-end system for
designing and fabricating machined parts on CNC equipment. This system, called "First-Cut",
supports detailed design and high-level process planning, tasks that sit at the interface between
design and manufacturing.
 Concurrent product and process design 367

2.1. System overview

One of the goals in developing First-Cut was to provide a rapid prototyping environment that
could be used by students in design and manufacturing courses at Stanford. In such an
environment, design for manufacturability is foremost a question of assuring that any part designed
on the system can actually be fabricated with available machines, tools and fixtures. We therefore
decided to make First-Cut a system in which the designers work close to the metal-cutting process
and in which the capabilities and limitations of the shop equipment are manifest.
The architecture of First-Cut, shown in Fig. 1, consists of a user interface and expert systems
that share knowledge bases and utilities such as a planner and spatial reasoner. The team members
communicate directly by message passing, as well as indirectly, via a shared representation of the
evolving design and process plans. The principal team members are as follows:
• A user interface. The user interface, shown in Fig. 2, is the most visible
manifestation of the philosophy behind First-Cut. The interface maintains
multiple views of the design (as feature-based solid models, as process plans, etc.).
It also provides context-dependent menus for adding features or performing
operations and allows the user to graphically manipulate the knowledge bases.
The interface is easily customized to support different manufacturing models and
different points of view. When a change is entered in any of the views, the other
views are updated (where possible) to maintain consistency.
• Expert systems. First-Cut currently has a machining expert system and two CNC
machine tool experts. The machining expert is actually a collection of micro-
experts, each knowledgeable about some aspect of machining. There are individual
experts that know about making holes, pockets and other simple features, a
fixturing expert and a tooling expert. These systems draw both upon general
purpose utilities (e.g. the materials knowledge-base and the spatial reasoner) and
upon local knowledge-bases such as the tooling database shown in Fig. 3. The
CNC machine tool experts have the task of compiling high-level process plans into
low-level instructions for a particular machine. First-Cut has interfaces to two
3-axis CNC machines, a Matsuura machining center in the student machine shop,

reasoner : gOO
pha_l ] I comsion [mAk,
hole II ~ I
i' I checkers I'~''weeP I It~
i lsucc--~or I feature
~.. II ~nder~ I,~-~p°~ll --.
I... I

[ planner 1 --

I
(userkuterface
I~ rSepra~edendt~°gnns ~Ma:uura[
I

Fig. I. Architecture of First-Cut consisting of a distributed team of experts working with feature- and
process-based views of a design.
368 MARK R. CUTKOSKYand JAY M. TENENBAUM

;l 0EFRDLT
FIXTURE: UISE-CLRnP SHEET_METALFORMING NORMAL
E~RKB 0~ SPINDLEOFF FOflGING IOTOLEFIANCE[OBJECTI(~):
StoreKB SETUP>¢¢xuu Del(:ltbs
Describe ' ~!
N Ol " Ri~ iM ~A L~ °~ ° ~ ROUNDNESS[OBJECT](" ):
LOAD_PARTS , LOCATIONAC CURACY[OBJECI'X*1:
STORE_PARTS INORMAL
START_UP_IMPULSE I YCOORDINA]£[REAL](*): o
CALLSUNCORE I XCOORDINATE[REAL]('0):
tOGGLE_DISPLAY_SETUP
I HOLEDEPlt(REAL]:0.TS
CREATEP I ~ I HOLIEDIAMLL"~'RrRF.AI.|
o.73
:
il !i DISPLAYPICTURE I -- "
GENEFIATE_NC_CODEI

MAKEHOLE
il [ FIOTATE j ~
REffrANI~L~I~,ET
R~&e'r
CoL~rngqB~
COUNllERDRILL
CONTOURPOCKET
Done

Fig. 2. First-Cut user interface showing process plans (top window), solid model and wire frame
projections. Other windows show menus of system commands, manufacturing modes and operations and
the low-level CNC instructions. A sub-menu shows parameters for the make-hole operation.

and a Dynamite mini-mill which is located adjacent to one of the workstations

as a table-top "hard copy" device. In addition, the machining interfaces include
routines for monitoring sensor data during machining and interpreting the data
in terms of common manufacturing errors.
• Shared knowledge bases. General-purpose manufacturing knowledge is contained
in a set of knowledge bases that are shared by the expert systems and can be
browsed by the designer. The knowledge bases exploit the features of modern
object-oriented data structures including heavy reliance on hierarchy and multiple
inheritance to organize information in a compact and semantically meaningful
format. First-Cut currently has one shared knowledge base, of materials and their
physical properties, which should be regarded as a prototype. It includes
machinable alloys, plastics for injection molding (some of which are also
machinable) and the materials of cutting tools. Figure 4 shows a portion of the
materials knowledge base loaded into the graphical editor. An example of multiple
inheritance is seen in the steel alloys which inherit properties of ferrous alloys, heat
treatments and forming processes.
• Utilities. Utility modules provide generic services to other experts in the system.
In First-Cut the utilities include a simulator/spatial reasoner and a primitive
planner. The spatial reasoner is responsible for maintaining the geometric
representation of the design and for performing simulations of manufacturing
processes. The spatial reasoner includes procedures for checking interferences and
computing transformations. We have found that spatial reasoning is perhaps the
single most difficult task in combining design with process planning. Currently,
no single solid modeling package meets all of our requirements. At different times.
 Concurrent product and process design 369

GENEI~110NS: R"~ICALOBJECT
MACFgNETOOL GROUPS:FCFC
WPE: CLASS
Edted: 23-Jun-881~07~6 POT
~y: TW
C/~J~IP TOOL-NUMBER[INTEGER]:NIL
SE TOOL-MATERIAL[OBJECTJ:M2-HSS
:IXTURE STRIP_CLAMp TOOL-I.ENG1TI[RF.AL]:
SHANK-LENGTI.I(RF..~.L]:
--V-BLOCK CUTRNG-EDGE-LENGTI~REAL]:
~I.ATHE-TOOL~ATHE-01 OBJECT:SINGLEPOINT-TOOL
SINGLEPOINT-TOOL~-BORING-TOOL~BORING-01 GENERALIZATIONS: TOOLS
SYNONYMS: I
~FLYCUTI1ER~FLYCUT~R-01 GROUPS:FCFC
WPE: CLASS
/COUNTERSINK-01 Edbd: 14-Jun-861~,4,~-~PDT I
COUNTERSIHK-TOOL<~ By:. T~I ,\
"~COUNTERSINK-0Z ANSI-CODE[B~R]: A
DRILL.TOOL~,.,,ORILL-OZ SHANK'WIDTH[REAL]:NIL !
OBJECT ""DRILL-OI OBJECT:MULTIPOINT-TOOL
/ENOMILL-03 S~fNONYMS: :~
~'OOLS /.ENDMILL-01 GENERN.IZATIONS:TOOLS ;~
GROUPS:FCFC I~,
y~Et~OMILL-OZ WPE: CLASS
MULTIPOINT-TOOI --ENDMILL-TOOL~ N D M ILL-04 Edited:
By,: TseJ14..dua-9813:~:04PDT
~ENDMILL-05 TOOL-DIAM1E~R[REAL]:NIL
ASA*CODE[E:~RI:
~ENDMILL-06 SHANK-OIA[REAL]:NIL
COUNTERBOR[.-TOOL~ COUNTEREOfE-01
r ~ S ] :
I
I
TAP-TOOL--TAP-01 OBJECT:DRILL-TOOL
S~I4OIWMS:
/BALLMILL-01 GENERALIZATIONS:MULTIPOINT-TOOL '
BALLMILL-TO0Lz-..BAL
< LMI
~ LL.O GROUPS:FCFC
I~fPI=:CLASS
/TOOL-POST EdltRd: 27-Sept-8817:39~36PDT I
TOOI-HOLDER~"DRIM'CRUCK By: Fcuser
POINT-ANGLE[REAL]:
~I.AITIE-COU.ET HElLE[REAL]:
FLU1E#pmE~TFt]: Z

Fig. 3. A graphical view of a tooling knowledge base used by the tool-choice expert.

we use both C.S.G. and boundary representations for incremental collision

checking, verification of break-through conditions, modeling sweeps, fixture
planning and tool-path planning. Currently, we use Alpha_l [7] and Vantage [8]
for visualizing designs and performing accurate interference checks, and wire
frame projections for fast graphical interaction. The planner is currently the least
developed member of the First-Cut team and is largely relegated to propagating
constraints. At the time of writing, there is no provision in First-Cut for
optimizing process plans. Development of an incremental planner/replanner is in
progress.

In the following sections we illustrate the operation and user interface of First-Cut through an
example involving a machined pillow block, and discuss preliminary versions of First-Cut for
assembly and injection molding.

2.2. Working with First-Cut: an example

Figure 2 shows the screen of First-Cut, several steps into a design session. The designer is creating
an aluminum pillow block in "machining mode". The pillow block contains a main bore into which
a bushing will be pressed, and counter-bored holes for two socket-head bolts. We assume that the
preliminary design is complete and that the designer is armed with a sketch of the part, giving
important dimensions and an approximate shape.
The screen of First-Cut displays menus listing the operations that are possible at any instant.
At the start of the design, the only possible operation is to select a blank for the incoming material.
As soon as the designer picks "select-blank", First-Cut provides additional pop-up menus for
specifying the material, dimensions, and other attributes of the blank. These menus are initially-
filled with default values that system will use unless the designer specifies otherwise. In this case,
370 MARK R. CUTKOSKYand JAY M. TENENBAUM

fL ~ 10,30.ANNEALE
D ~me¢-~ i I'~.~~r:r~lP.L
SYNONYMS:

[/t
1030NORMALIZED GENERALIZATIONS: OBJECT
GROUPS:MATERIALFCFC
1030HOTROLLED TYPE:CLASS
.1015 ANNEALED Edited: ,9-Sept 8B1,03:51PDT
t ~y: Tsal
ARBONSTEEL 1015NORMALIZED DESIGNA~ON[~<PR]:
l015 HOTROLLED SPECIFIC WEIGHI[REAL]:
4ACHININGSTEEL
!I
UM-ALLO!~~II
i YIELDSTRENGTH[REAL]:
ELASTICITY-MODULUS{REAL]:
FRACTURE-TOUGHNES~REAL]:
LLOY MACHINABlUTY-.INDEX[ REAIJ:
It
I-ALLOY ~ SPEClFIC-CUTTINGPOWER[RFN.]
¢~/!~ WORKHARDENNINGCOEF[REAL]:
AVNLABLE-SHAPE[E)4PR]:
t ~,, ow~RAss,,,, ,,OISSO,,,-~TIOt,~R]:
f'Vff//"RED BRASS MELT1NG-POIN~EXPR]:
~L l l It DOCUMENTATION[TE)ffJ:
t /~I/O/NZE SIHCON
till BRONZE ENDURANCE STRENGI~E)~R]:
COPPERAND-HIGI4COPPERALLOY--LEAD THERMALEXPANSIOHCOEP[~R
~/III~/~I V it t i l l SHEAR-$TRENGTH[EXPR]:
1000-SERIES HARDNES~E)~R]:
II Illl TENSILE-STRENGTH[EXPR]:
I SERIES 7 z024-T4 i
II tIN
f/ t~00-SERIE$-t
II Ill P
~00 SERIES~7075"T651 SYNONYMS:
IGr~ N G ~ GENERALIZATIONS:
TREATMENT SOLUq
AGING6000 ION-HEAT-
SERIES
GROUPS:MATERIALFCFC
i TYPE:INDIVIDUAL
Edited:14-Sept-B8~1',~:05PDT By:
Tul
SPECIFICJ~EIGIflIREAL]:o,ogB
JEVI HARDMESS[REAL]:gS-HG
~EAT.TREATM~IT/ Y1ELD'mENGTH[REAL]:40
f ELASTICrlYMODULUS[REAL]:lO
DESIGNATION[EXPR]:6061
~TED STATI~E)(PR]:(SOLUTIONHEATTREATMENTAI~
ENDURANCE~S1R ENGTH[E)~R]:14
pRGED I TENIllLE-~ITRENQTH[E)~R]:45
........ 1TIERMAL-E)~ANSION-COEF[EXPR]: 13

Fig. 4. A graphical view of the materials knowledge base, showing multiple inheritance.

the material is 6061-T6 aluminum, and First-Cut indicates preferred sizes for aluminum stock. A
wire-frame image of the blank appears in a window, with projections or cross-sections for graphic
interaction. A shaded image is displayed by First-Cut's solid modeler in a second window. A third
window displays the process plan, as a sequence of icons corresponding to operations on the part.
All windows can be moved and resized at will, and additional windows can be invoked to interact
with the knowledge bases if needed.
Once a blank is selected, the available operations include make-pocket, make-hole and make-slot.
The designer begins by adding one of the bolt holes. To do this, he selects make-hole in the
operations menu and then specifies make-counterbored-hole in the submenu that pops up. The
designer indicates that he wants a hole for a 1/4-20 UNC socket head bolt (which determines the
dimensions of the hole and counter-bore) and specifies the desired location, either by pointing to
it with the mouse or by editing the coordinates. At this point the fixturing and tooling experts come
to life. The first approach is to see if a default combination of fixtures and tooling could be used.
For example, the fixture planner determines that a vise could hold the part. The spatial reasoner
is called to check for geometric interferences. Where possible, the checks are accomplished with
rectangular bounding boxes for speed.
Looking at the process plan window, we see that "setup" and "make-counterbored-hole" icons
have now been added to the process plan. An important feature of First-Cut is that these process
steps can be directly inspected and edited by the designer. To change the make-counterbored-hole
step, the designer clicks on its icon, producing a pop-up window containing the details of the
operation. Modifying the hole_diameter or counterbore_depth produces attendant changes in the
graphics windows. Sections of the process plan can also be cut and pasted as a way of adding to
the design. For example, an easy way to make a second hole is to select and copy the existing
make-counterbored-hole icon, modify its location attribute, and paste the result onto the end of
the process plan.
 Concurrent product and process design 371

In the next step, the designer creates the main bore that will be used for holding a bushing. The
designer picks a chamfered-hole to facilitate later assembly. The fixturing and tooling experts
function as before, except that the block must be re-oriented. Therefore "reorient" and "setup"
steps are automatically added to the process plan. Since the hole requires a close diametral
tolerance, First-Cut decides to make it by center-drilling, drilling and reaming on the Matsuura
or by milling with a measured end mill on the Dynamyte. These lower-level process steps are not
shown in the iconic process plan but can be inspected and edited if desired.
Alternative designs can be represented by branches in the process plan. For example, the
possibility of a cheaper pillow block without close tolerances on the chamfered hole can be
investigated by specifying "copy subtree" at the make-hole step in the plan. This command
produces a branch in the plan, with a copy of the steps from the original plan. If the hole tolerances
are loosened, the make-hole expert will determine that it can make the hole without reaming.
Alternatively, the designer can simply delete the reaming substep from the new branch of the plan.
The process plan in Fig. 2 shows the start of a branch with relaxed tolerances.
Remaining operations will follow the same pattern as those above. The details of fixture
planning, tool choice and tool path generation are generally invisible, although they can be
inspected and modified if desired. The experts try a default value first, but if the default fails they
search for other solutions. If no acceptable combination of fixturing, tooling and tool-path can be
found, First-Cut will ask the designer to try something different (perhaps specifying a different
operation, relaxing some tolerances or even backtracking several steps in the plan).
CNC machine instructions for producing the part can be generated at any stage by clicking on
the "NC_generation" menu. Thus, it is possible to make a prototype (perhaps for inspection or
testing) of a design that is only partially complete, while the designer works on additional details.
The machine code is accompanied by instructions to an operator for fixturing the part and loading
cutting tools. (A portion of the CNC instructions window is visible in Fig. 2.)
Finally, as the pillow block is machined, a feedback program associated with First-Cut monitors
the forces, torques, vibrations and sounds generated during the cutting process. These signals are
filtered and correlated with the CNC program to provide a processing history which we can use
for troubleshooting the system and modifying the knowledge bases if needed. For example, if
chatter is detected, the culprit might be faulty fixturing, improperly specified speeds and feeds or
a worn tool [9].

2.3. Assembly and injection molding modes

We have begun to develop two additional modes in First-Cut: assembly and injection molding.
While these modes are much less developed than machining mode they follow the same style and
general approach.
The motivation for studying assembly is primarily that it permits us to work on vertical
integration and tolerance propagation so that machined parts will fit and work according to
functional requirements. Figure 5 shows the user interface after the designer has popped into
assembly mode to assemble two machined components: a plate with a hole and a cylindrical peg.
The operations_menu resembles the menu for machining except that it now contains operations
like "insert .... attach" and "align". Other windows show graphical representations of the assembled
parts and a "connectivity tree" of the assembly. After each step we compute the positions and
orientations for the parts, following the method of Mazer [10]. Finally, just as the machining mode
generates a code for a CNC machine tool, the assembly mode generates VAL-II [1 l] instructions
which can be down-loaded into an assembly robot.
A third manufacturing mode in First-Cut is injection molding. Injection molding is interesting
because it uses very different geometric primitives from machining and is less suited to description
in terms of a sequence of icons corresponding to process steps. We have capitalized on the fact
that most injection molded parts are thin-walled, and have provided a thin-wall primitive for
defining the overall component shape. We also provide a catalog of features (e.g. ribs, bosses, holes)
that the designer can paste onto the walls. The materials knowledge base in First-Cut has been
extended to include resins and micro-experts have been written for determining draft angles, corner
radii, etc, depending on the resin and the geometry of the part. The designer begins by drawing
cross sections of the main walls of the component in a commercial CAD system [12]. The drawing
372 MARK R. CUTKOSKYand JAY M. TENENBAUM

I MAQ.flNU~
INJECTION MOLDIN(3
F~ING
SUIIF/UCEFHSlIOBJECT](-):
NOmAAL
IDTOLERAHCE[OBJECTX"):
NORMAL
ROUNDNESS[OBJECT'I'):
LOCATIONACCURACY[OBJECTJ("):
JORMAL
I STARTNE'WA,~g~ILY [ WHOLE.,SOO-1 HOLEDEPTH[REN.]('):O.25
STORE_A~MBLY ~ YCOORDINAI~qRF.8~-}: (COI'~UTE
GENERATE_ROOOTIC_CODE ROUND-~'R-92 RECTANGULAR-BAR-71 XCOORDINATE[REN~'):(COMPUTE
NEW SUBASSEMBLY HOLEDIAMETER[REAL]:1
COADPART
cof~Ec'r_PAm'S

.._..t__._
GROUPS:
TYPE:INDIVIDUAL
SBE..X[REAL]:50.0
SIZE Y[REAL]:101.S
:" "~ ;"" • SIZE Z[REAL]:
i l.
, ,_. . . . . . . .
::i oma..~o=~
~BFI~EN~.FR~tq, I ~ MKmlXI:e . , ~ - , ~ r ~ T (4 4) 11
F~11JRS LI~O~IE~I: I.~E-~
COMPONIBi~OBJECTJ:NIL
PART OF[OBJECT]:WHOLE-SOO-1
ASSEMOL~OOJECTJ:WHOLE-SO0-1
FINAL_REFEIRENCE_FRAME[4~_MATRIKI:#.Sbtole-Atmy"~

Fig. 5. First-Cut user interface after a designer has popped from machining mode into assembly mode
to insert a peg ("round bar") into a hole in a block ("rectangular bar") of metal. One window shows
the process plan, a second shows a connectivitygraph for the assembly, a third shows projectionsof the
assembly and additional windows provide menus of operations and parameters.

is loaded into First-Cut, and, with the designer's guidance, feature-finders (e.g. wall-finders and
corner-finders) identify features. First-Cut then modifies the geometry to produce cross sections
with preferred draft angles, thicknesses and corner radii. The designer adds small features such as
bosses and ribs. Finally, the modified part is shipped back to the CAD system for display.

3. D E S I G N R E P R E S E N T A T I O N
The design representation in First-Cut is at the heart of its ability to link computer aided design
and manufacturing. The design is represented in an object-oriented data structure, the objects
correspond to functional, geometric and manufacturing features. As an example, Fig. 6 shows
First-Cut's representation for a machined pneumatic manifold block. There are two ways of
viewing this design representation: as a hierarchy of manufacturing, geometric and functional
features and as a series of processes or programs at different levels of detail.
In the hierarchical view (top to bottom), each box corresponds to a feature. At the highest level
is a functional description. As we move down the tree, we progress from functional, to geometric
to manufacturing features. Features can be decomposed into more detailed features and agglom-
erated into macro-features. For example, a macro-design feature such as a bolt circle is decomposed
into the primitive holes that compose it. Similarly, a manufacturing step for making a threaded
hole is decomposed into center-drill, drill and tap. Steps can also be grouped into macro-steps,
corresponding to design features.
Every feature and process step has an explicit purpose or purposes. Knowing the purpose is
essential for refining and reusing plans in ways that preserve a designer's intent. At the top level,
the purpose of the manifold block is to support and locate several solenoid valves and to conduct
air to them. Therefore, the elements of the manifold should singly or in combination fulfill these
purposes. Process steps also have explicit purposes. Often, the purpose of a step is to contribute
 Concurrent product and process design 373

relaUon to other
components in an
assembly

functional des~lption /
[ lmeumatSc,,,,m'd~ld ' I
J purpose: <amduet aB',loeate,m~portv~r¢o
~ cc~stro~ts: • > ,,

~ other
features of
the manifold

m a c r o features / I purpose:<locate,suppo~valve>i
/ I~ . ~ol..~.d~ . . . . . I
/ I • > J
~ in~Lu~tivet u t m ~ /
and h i g h - l e v e l / d J k /

~ / h°~ llho~ I
r _ _ _ . ~ l~1~se: <conductair>F...r,~ purpo~: <lot.,cL,ele>i___i,~ pu~1~oe:<lot,,cU~k>~
Iho~ /

~ ~ ..,.,~ __---~-~. ...... U ,c~.~...-..~ . . . . . , ,--:<...> _ _

low-level
p ~ e a s plan j ~
lUlOa~: <...> ~ p u r p c e e : <...> 1F 1- - P . , d ~ <.,.> l
mu.lbutm: <...> ~ e m ' l S u t m : <...> I'-I.,,'lm~mmu: <...>
>1 l= m ffi < .... J l .... !

purpose of operations transm/tted forward

D
process oriented preconditions transmitted backward
t
Fig. 6. Partial representation the design representation of a pneumatic manifold, showing both a hierarchy
of features and a series of process plans.

to the realization of one or more features (e.g. "make the chamfered hole that holds the bushing").
Other process steps may help prepare for a manufacturing operation (e.g. a center-drill operation)
and still others may have both a functional and manufacturing purpose, such as a machined face
on a design that also serves as a locating surface during manufacture.
In general, every feature is linked to features at adjacent levels of the hierarchy with relations
that encode purpose, rationale and constraints. Through this relational network, it is possible, for
example, for users to trace how a top-level functional specification is realized in a design and then
implemented by specific steps in a manufacturing plan. Conversely, the justification for a
manufacturing tolerance can be traced all the way back to a top-level requirement (e.g. "minimize
vibration"). Making such information explicit facilitates re-using a design, or fabricating it with
a different manufacturing process. The situation is analogous to a well-known problem in software
design: determining "what in the code implements what in the specs" [13].
In the process-oriented view (left to right) of Fig. 6, each box represents an operation for making
the associated feature. The boxes have inputs, outputs, preconditions and purposes. At the upper
levels we construct designs and high-level manufacturing plans. Plans are normally represented as
sequence of steps, corresponding to high-level machining operations, or at lower levels, to detailed
manufacturing instructions. In either case, the result is a tunable, process-oriented description of
the design; in other words, a program, in the same sense that Lisp code is a runable description.
The analogues to purpose and functional constraints in the hierarchical view, are temporal
constraints and side-effects in the process view. For example, manufacturing features have

MMT25/~-1'
374 MARKR. CUTKOSKYand JAYM. TENENBAUM

preconditions which relate them temporally to other features at the same level in the hierarchy.
The representation encodes that constraint that a hole cannot be drilled without a center drill
operation. On the other hand, a series of holes can be drilled in any order and decomposed so that
all center-drilling is done first.
Combining features and plans, the high-level "macro" corresponding to a repeated design feature
(e.g. an array of holes) can be expanded into the steps associated with each instance of the primitive
feature and a conditional that controls the looping. In this fashion, a high-level skeletal plan, such
as the plan in Fig. 2, can be progressively fleshed out into a series of detailed machining steps.

4. EXTENSIONS
First-Cut isn't very big or knowledgeable as yet, but it is proving to be a good framework to
build upon. We are starting to expand the scope of our project, enhancing First-Cut's competence
in machining, and extending it beyond machining to support multiple manufacturing modes and
multiple stages in the design cycle (from early to final design).
Much of our ongoing work is directed toward making First-Cut a useful rapid prototyping
environment for students designing and fabricating machined parts and assemblies in the student
shops. The motivation here is to acquire a base of users who will both evaluate the system and
add to it.
We also want to demonstrate expert performance in a narrow domain that forces us to exploit
the interactive problem solving approach supported by First-Cut. A simple example would be the
manufacture of parts with pockets, taking into account tool deflections, interferences, thin walls
and ribs, deformations from clamping, etc.
Two longer-term goals are: (1) extending First-Cut to support the design and fabrication of
simple electromechanical assemblies composed of components selected from catalogs and parts
machined using First-Cut and (2) redesigning a machined part for mass production via injection
molding. In these areas we will build upon the preliminary versions of assembly and injection
molding mode that we have begun. Electromechanical assembly will push First-Cut toward
conceptual design and modeling, analysis, and design tradeoffs involving multiple technologies,
multiple parts and multiple manufacturing modes. Redesigning prototype parts for injection
molding will force us to develop explicit rationale and intent in our design representation. In the
remainder of this section, we discuss specific ways are extending First-Cut to accomplish these
goals.
4.1. Increasing First-Cut's knowledge
First-Cut knows a little about machining parameters, tool choice, fixturing and tool-path
planning, and almost nothing about such issues as surface finishes, tolerances, tool deflections and
flexible parts, that arise in precision machining. Knowledge acquisition is thus a near-term priority.
Fortunately, the modularization of knowledge afforded by a team of experts makes adding new
expertise relatively straightforward. To bound the problem, we are capturing the knowledge
contained in the notes for Stanford's rapid prototyping class, ME-103, [14]. Here, students learn
to machine a few basic features, utilizing a small repertoire of tools and clamps. They also learn
the rudiments of fixturing and tolerancing and about tool-related phenomena such as forces,
friction and chatter.
Some of the knowledge contained in the ME-103 course notes can be represented with rules,
tables and procedures. For example, there are machining parameters (e.g. recommended speeds and
feeds), and rules of thumb (e.g. "don't use an end mill for plunging unless it is a center-cutting
mill"). Rules cover common situations and, where applicable, they are much faster than numerical
simulations or symbolic reasoning "from first principles". However, for spatial and physical
reasoning problems, such as path planning, it is impractical to construct rules for every case. As
a result, we need qualitative and quantitative analyses and simulations. Symbolic analyses (e.g.
solving equations) and abstract simulations capture the essentials of geometry without unnecessary
detail [15].
Many of the spatial and physical reasoning tasks are common to different domains and
applications. For example, fixture planning, grasp planning, robot path planning and tool path
 Concurrent product and process design 375

planning all draw upon some of the same geometric and physical representations and use similar
vocabularies of features. Therefore, it makes sense to define general-purpose "utilities" for path
planning, interference checking, stability checking, etc.

4.2. Support for cooperative, distributed design

Today, First-Cut provides windows with different views of the design on a single screen. In the
future, we will support a distributed version in which different members of a design organization
will be able to work concurrently on a design, each with a workstation displaying windows that
depict pertinent aspects of the design in a familiar form.

4.3. Extensions to other manufacturing modes and stages in the design cycle
We view design as a continual process of elaborating and refining a design over its life cycle.
Today First-Cut supports detailed design and process planning, but ultimately, it needs to support
multiple manufacturing modes and multiple stages in the design cycle. To illustrate a few of the
issues which we are addressing, consider the pillow block from Section 2. In machining mode the
part becomes more manufacturable if we relax tolerances on the main bore (as in the second branch
in the plan) so that it can be made with just an end mill. But this is unacceptable, since the purpose
of the hole is to hold a bearing, which requires a light press fit and close tolerances. Similarly, for
assembly we would prefer some clearance between the hole and the mating bearing, which is
unacceptable from a functional standpoint. On the other hand, adding a chamfer to the hole adds
little to the machining cost, has no effect on the functional performance of the hole and greatly
facilitates assembly.
Harder issues are raised when redesigning a machined prototype for mass production by injection
molding. Since the process constraints are different, we should expect that the final geometry will
be different. Although some features (e.g. holes) exist in both modes, the design should be
completely replanned in the new mode for best results. Any attempt to translate directly from the
features of one mode to another is likely to resemble a literal translation, say, from French to
English.

4.4. Closing the loop

We maintain that effective CAD/CAM integration requires two-way communications all the way
from design to the shop floor. Thus, we are extending the programs we have for monitoring the
execution of process plans on the shop floor so that First-Cut can interpret sensor data in terms
of salient manufacturing events (e.g. worn tools or inadequately clamped parts) [9]. The resulting
information is useful to designers in two ways: they obtain process histories that they can use for
"debugging" designs and process plans, and they obtain the benefit of machining knowledge bases
that reflect the latest shop floor experience. For example, if it is found that cutting forces and
vibrations are lower than expected for a particular tool, more aggressive speeds and feeds can be
used in the future, which may make a feature practical to fabricate.

5. D I S C U S S I O N
In the following section we expand on our design philosophy and, drawing on our experience
with First-Cut, we examine concurrent product and process design in the context of other design
styles such as constraint-based design and feature-based design.
First-Cut raises some basic questions about design methodology: are "manufacturing modes"
a good way to design? Will designers find the approach fast and versatile or tedious and confining?
Will it enhance or impede creativity? In responding to these questions, we should first point out
that First-Cut was not intended as a complete design environment. Today, First-Cut is a useful,
high-level process planning tool. With its explicit process representation and manufacturing
knowledge, it is already easier to use and more powerful than existing NC programming
environments. First-Cut is also becoming an increasingly useful environment for detailed design
of components and assemblies, especially when it is desirable to create prototypes very rapidly. In
the future, we hope that First-Cut will encompass conceptual design.
376 MARKR. CUTKOSKYand JAYM. TENENBAUM

~ ii~iii~iiii~iiii~iii~i~i~iiiii:!iii~i~i~i~i~i~!~i~i`i~ii!~ii~i~iiii~i~i~i~i~i~ii~!~i~i~i~iiii!~+
iii~ii!i~
i~iii~i/ii~!i~ii~iiii~i~ii~i~ii~ili:;ii
i!~ ~iiiii~i~i~ili ~i~
increasingly increasingly
decoupled concurrent
Fig. 7. A spectrum of approaches to design and process planning: the conventional approach is at
the left end; design and manufacturingare virtuallydecoupled.Concurrent product and process design
is at the other extreme. In between, are design/testing/prototypingenvironments that permit rapid
iteration.

Stepping back a bit, we can see that the process-oriented style of today's First-Cut is at one end
of a spectrum of approaches to design and manufacturing as shown in Fig. 7. The opposite end
is represented by the traditional approach in which design and manufacturing are virtually
decoupled, and completed designs are "thrown over the wall" to the production department. The
problems with the traditional approach are well-known: high manufacturing costs, numerous
last-minute engineering change-orders, long time to market, etc. But design in First-Cut has
limitations too. It works best for detailed design, when the designer is already committed to a
manufacturing process, and, ideally, a particular manufacturing facility. However, the methodol-
ogy and computational framework behind First-Cut transcend machining and assembly, extending
to other manufacturing modes and stages in the life-cycle of a design. Thus, in discussing the design
methodology behind First-Cut we return to the essence of concurrent product and process design:
to do as much modeling, analysis, simulation and planning as practical at each step so that we catch
problems early and minimize backtracking. This is not specifically tied to design in manufacturing
modes or to detailed component design. While First-Cut has focused on incremental feedback from
process planning, the same philosophy applies to feedback from other life-cycle considerations,
such as product operation, engineering analysis and serviceability. The amount of modeling,
analysis and feedback is limited, in practice, only by available computer cycles and the completeness
of the design (for example, certain analyses cannot be performed until the geometry has been
specified). The computational limitations can be overcome to some extent by resorting to
background processing for time consuming analyses.

5.1. Design in manufacturing modes

An essenval idea behind manufacturing modes is that characteristics of materials and processes
should be incorporated into the user interface. Each mode suggests new styles of user interaction
that capture the "feel" of the domain. In discussions with designers and manufacturing engineers
from industry, we have found that while they agree that manufactuirng modes will make process
characteristics manifest to designers, they also express concerns about manufacturing modes as a
style of design. We consider each of these concerns below.
Will manufacturing modes hamper designers?A system that reflects process characteristics is not
a hindrance if it is fast and powerful. The way to increase speed and power is to find the right
level of abstraction for representing the process; one that captures the essential characteristics and
constraints without too much detail. Thus, the right level of abstraction for machining is at the
level of material removal ("make hole", not "center drill, drill and ream"). The key to doing this
 Concurrent product and process design 377

in practice, is to rely on expert systems to fill in details. In fact, working in machining mode need
not be much different from other feature-based CAD systems.
Will attention to manufacturing processes reduce creativity? To the contrary, we find that an
intuitive feel for materials and processes may enhance creativity. As an experienced model-maker
puts it: "I often design while I am fabricating. For me, holding a piece of metal or plastic suggests
solutions. I don't know where that sensitivity, that empathy for the material comes from, but I
think that if one is just trained in the equations of the material properties without having physically
manipulated them, one misses a lot of intuitive design opportunities" [14].
The computer can provide the designer with a sensitivity for materials and processes in
several ways. At the lowest level, the system provides designers with "virtual tools" that capture
the feel and constraints of the medium. Defining complex operations, like sweeps, by graphically
moving a tool through 3D space captures manufacturing constraints much better than a set of
rules. Having a designer specify a pocket by sweeping an imaginary mill over the part (even if the
designer doesn't know it is an end-mill), will lead automatically to selecting the largest diameter
mill to minimize the amount of time spent constructing the feature. At higher levels, design in
manufacturing modes is akin to designing with features, except that the features assume preferred
dimensions and geometries for the process under consideration, For example, a boss or a
flange in machining mode will look and behave differently than a boss or flange in injection molding
mode.
Manufacturing modes can stimulate designers in other ways as well. For example, it is
well-known that it is hard to get started on a creative design project when presented with a blank
slate. Adding some extra (relaxable) constraints is a good way to stimulate thought, and can result
in novel solutions. The artificially constrained design space is faster to explore and, if a solution
can be found, the result is often cheaper and simpler than what was originally contemplated. For
instance, a designer may ask if a particular design could be made entirely from plastic. The use
of plastics limits the range of possible geometries and suggests the use of flexures instead of pivots
and snap fits instead of screws. Another example might be to impose the constraint that a
mechanism be strictly 2D. If a solution can be devised, the result is likely to be very compact. The
2D mechanisms of a Winchester rifle are a good example [16]. If a solution cannot be found, the
result will at least be a better appreciation of how to use three dimensions.
Rapid-prototyping also fosters creativity. Ultimately, by providing a safe, economical, rapid-
prototyping environment, we hope that First-Cut will turn students into "mechanical design
hackers", infected with the same enthusiasm that keeps software hackers up all night devising new
designs. We wish to create an environment similar to that of software or VLSI design [17] where
it is easy to try out new ideas, the rewards for successful design are immediate, and the price for
errors is low. In fact, writing a process plan is literally programming, and doing it graphically is
programming at a level of abstraction higher than that available to many computer science
students.
Will we mislead designers with "myopic" process views? Another concern voiced about design in
manufacturing modes, is that by providing immediate feedback, we may mislead designers with
a myopic view of the overall design/manufacturing problem. After all, if the part is not finished,
we cannot have a complete plan; and perhaps we should not provide feedback on the basis of
incomplete and globally suboptimal plans. Certainly, we have to be careful about suggesting too
strongly what is better or worse in terms of manufacturability. However, feedback in First-Cut is
largely based on what is feasible, not optimal. Also, the user can suspend process planning and
feedback at any time or restrict it to high-level planning. Indeed, we defer detailed process planning
and NC code generation since it is impractical to generate NC code on a step-by-step basis as the
designer enters new features. Instead, the designer selects "generate NC code" when ready either
to produce a part or to subject the design to detailed manufacturing analysis; the low level plan
generation runs in the background, using all features entered thus far as its basis for computing.
Looking toward future versions of First-Cut, it would be a mistake to treat manufacturing experts
as "critics", commenting on each feature as it is added or computing manufacturing costs as a cash
register on the screen. Instead, working with the team of experts should be closer to brainstorming
with a machinist, who can improve the design by suggesting ways to exploit the manufacturing
process in addition to pointing out features that are difficult to produce.
378 MARKR. CUTKOSKVand JAYM. TENENBAUM

Are manufacturing modes suitable only for detailed designT A final concern about manufacturing
modes is that they are fundamentally only suitable for detailed component design. This is at least
partly true, as far as the current version of First-Cut is concerned. However, we intend to provide
multiple levels of design with appropriately abstracted levels of manufacturing planning and
feedback. An important research issue concerns determining what engineering and manufacturing
knowledge and constraints are needed in preliminary design and determining the appropriate level
of abstraction at which to represent them. The details of processes are clearly inappropriate when
no process has been decided upon, and yet good designers are always aware of the range of
materials and process capabilities available to them. Does it suffice to abstract manufacturing
details to a choice of materials and fabrication process? At the same time, we need to understand
how preliminary design choices should influence detailed design. For example, how do we use
functional and geometric constraints from a conceptual design as input to the manufacturing
modes?

5.2. Design as programming

An important concept in First-Cut is that design and process planning can be viewed as
programming. The connection between process planning and programming is most straight-
forward: the designer or manufacturing engineer works with a high-level representation of the
process plan in a visual programming language, much like Petri Nets [18]. The process plan can
be edited, cut and pasted, and loops, branches and conditionals can be added, as in any
programming language. The steps also have inputs and outputs like the procedures in a
programming language. Finally, the process plan can be run as a procedure and stored in a library
for reuse.
The visual programming viewpoint is especially useful for combining features into macros and
subsequently pasting them, along with their associated fragments of process plans, onto a design.
Our goal is to allow the designer to "program" such features in a way that seems natural from
the standpoint of design. In other words, the designer should not have to leave the design
environment and resort to Lisp in order to define new features. However, when pasting features,
considerable checking and constraint propagation must take place. It is necessary to establish that
the preconditions of each step are satisfied, along with global manufacturing and geometric
constraints. For example, suppose a designer decides to modify an earlier design for a metal cover
plate by adding a "grill" macro, defined as an array of slots. What are the effects on the
manufacturability of the part? Not only must the system check the manufacturability of the grill
itself, but the influence of the grill on other parts of the process plan must also be considered. Can
the surface still be used for indexing the part in subsequent operations, and will the part still be
rigid enough for the previous fixtures to work? The design-as-visual-programming analogy brings
such needs to the surface. By treating the macro features as fragments of programs, with explicit
purposes, preconditions and input/output relationships, it is inescapable that pasting features must
be treated as carefully as pasting sections of code in a program.
When the designer moves down to the level of manufacturing primitives, the programming
analogy is again useful. Going to lower levels in the hierarchy is analogous to switching from a
high-level language to assembly code in order to manipulate something that the high-level language
doesn't provide for. At the bottom level, the designer works with "tools with feel"; a bit like
"teaching by showing" in robot programming.

5.3. Relationship of concurrent design to feature-based CAD

Perhaps the closest existing analogue to design in First-Cut is feature-based CAD. Feature-based
CAD grew out of the realization that computer-aided systems could provide designers with a more
convenient design tool by permitting them to work directly with features such as threaded holes
and chamfers instead of geometric primitives. In addition, when a designer specifies that a feature
such as a chamfered, threaded hole is to be positioned somewhere on the part, the computer
immediately has access to all the attributes of chamfered, threaded holes, including their customary
tolerances, appearance and ways to manufacture them. The resulting model is a far more
appropriate input to a process planning system. The need to recognize and extract features from
a CAD model is also greatly reduced (though not eliminated, since manufacturing experts are often
 Concurrent product and process design 379

concerned with different features than designers). Luby et al. [19, 20] describe feature-based CAD
systems, combined with manufacturability experts for parts made with a variety of manufacturing
processes.
Despite their many strong points, feature-based CAD systems have drawn some criticism. First,
the vocabulary of potential features is endless, and no closed set of features is likely to satisfy
a designer [20]. In addition, the mapping between geometric features and manufacturing features
(i.e. features of the part that are important from a manufacturing standpoint) is often indirect. For
example, a hole is a geometric feature that may be machined in different ways depending on its
size, location, tolerances and juxtaposition with respect to other features. There are also
manufacturing features (e.g. a surface that is lightly machined so that it can be used for indexing
a part) that serve no role in the intended function of the design and may even be removed in
subsequent manufacturing operations. Finally, feature-based design has been criticized from the
standpoint of design methodology because it produces results that are too finished-looking too
soon, and therefore removes a level of abstraction that may be important in early design. While
design in manufacturing modes does not address the third, (which might be solved by providing
a "conceptual design mode") we argue that it directly addresses the first two:
• A closed set of features is incomplete for designing. Since a closed set of features
is incomplete, one needs to be able to create arbitrary features (which can lead
to feature explosion), or go back to lower primitives (lines or geometric solids in
the case of most CAD systems--with an attendant loss of information). As
discussed earlier, the definition of macros amounts to programming, since the
preconditions, purpose and parameters of the macro must be defined. Conse-
quently, most feature-based CAD systems require a programmer for defining new
features. However, through visual programming the designer can "program" his
own macro features. At a lower level, working with virtual tools enables a designer
to also define new primitive features.
• Features do not map directly to manufacturing plans. We have argued that process
planning after the fact, from a completed collection of features, is both hard to
do and suboptimal from the standpoint of design for manufacturability. The first
problem is that there are different kinds of features corresponding to different
points of view: geometric features, manufacturing features, analysis features and
so forth. Clearly, purely geometric features are an incomplete basis for generating
process plans. But even if one designs with manufacturing features (or finds a way
to map from geometric to manufacturing features) with specific slots for material
hardness, surface finish and so forth, the resulting representation is incomplete
since manufacturing features are context-dependent. A partial solution to this
problem is to provide features with explicit constraints on material condition,
adjacent features, etc. For example, a "flexure" or "hinge" feature for molded
plastic parts might include constraints on the type of resin and the local
orientation of polymer chains. In fact, such explicit constraints are an important
aspect of the features used in First-Cut. However, such features still lack temporal
constraints and procedural information that are essential for process planning.
Even associating features with fragments of process plans is inadequate since the
fragments themselves are context-dependent. The context problem has been
recognized by the CAD community and a partial solution is included in the
preliminary PDES specification [21], involving features with explicit temporal
constraints; for example, a hole feature in a sheet metal part that is to be made
after bending. However, it is more useful to have a complete, explicit repre-
sentation of the process history, which can be replayed for analysis and simulation
at design time. Therefore, we think it is more natural to use features for
representing the physical state of the part, and to link them to process repre-
sentations for temporal and procedural information.
In summary, features are a valuable but incomplete mechanism for design expression. We argue
that a dual representation, combining features and process plans at different levels of detail,
380 MARK R. CUTKOSKYand JAY M. TENENBAUM

overcomes many of the problems associated with a purely feature-based description and is the right
framework within which to build an end-to-end design tool.

5.4. Concurrent design and constraint-based CAD

Recently, considerable academic and commercial attention has been focused on parametric and
constraint-based design [23, 24]. For example, a linkage might be represented parametrically so that
when the designer stretches or shrinks the linkage, the various links remain connected and the
input/output velocity ratios are preserved. From a life-cycle perspective, the entire design process
can be viewed as an exercise in constraint negotiation, with large numbers of interacting constraints
from different stages (e.g. functional specifications, manufacturing limitations and human factors
contraints) [25]. A constraint-based design system helps the designer to manage and propagate
constraints throughout the design process.
Powerful as it is, this paradigm reflects a limited view of design. Even if one could explicate all
relevant constraints on form, function and process, there would remain a large space of acceptable
design solutions. The rest is up to the creativity and individual style of the designer. Exploring this
"acceptable" space is the realm of creative design, and for most designers, is what makes their jobs
fun. We believe that constraint-based design, creative design and design in manufacturing modes
are complementary. The greatest benefits will result from understanding how to merge them. Many
of the extensions discussed in Section 4 are directed toward this goal.

6. C O N C L U S I O N
In this paper we have presented a methodology for concurrent product and process design and
a computational framework that supports it. The distinguishing features of this approach are:
1. Manufacturing engineering is done as the design takes shape, instead of after it
has been completed.
2. The design/manufacturing process takes place in a highly interactive, distributed
environment consisting of teams of human and computer experts.
Supporting the methodology is a computational framework that exploits modern computer
science and A.I. technology to bridge the gap between design and manufacturing. The architecture
is inspired by human design teams and consists of a collection of human and computer experts
that interact with each other, and with the designer, to critique and fill in the details of evolving
designs and manufacturing plans. While First-Cut is incomplete, we can already say that it
combines some of the best attributes of leading approaches towards bridging design and
manufacturing, including simultaneous engineering, team design, rapid prototyping, feature-based
design and constraint-based design. Concurrent design:
• Extends traditional simultaneous engineering tools by providing instantaneous
feedback at each step of the design and by suggesting what can be done to improve
a design.
• Overcomes the limitations of human team design by augmenting people with
expert systems in a distributed "virtual team" environment.
• Supports rapid-prototyping for turning a conceptual design into hardware.
Prototypes can be fabricated and manufacturing experience gained from designs
even before they are completed.
• Improves on feature based design and process planning in several ways. It
provides a means to expand the feature set through visual programming and
programming by example. It makes process planning more tractable by perform-
ing it incrementally (and interactively where necessary). Finally, the process plan
provides a natural way to represent and reason about temporal and contextual
dependencies to ensure that features are appropriately used.
• Extends constraint-based design to encompass manufacturing (process and
material) constraints and enhances the designer's creativity by incorporating them
into user interfaces that encourage exploration of the medium.
 Concurrent product and process design 381

The ultimate goals of our research are to accelerate design cycles and permit designs that more
effectively exploit the potential of materials and processes. Whether concurrent product and process
design will achieve these goals and whether designers will accept it is in the last analysis empirical,
and so must await further experience with the system. Therefore, the thrust of the project over the
next year will be to provide First'Cut with the breadth of knowledge that students need to use it
in shop courses and with the depth of knowledge needed to demonstrate expert performance with
a limited family of parts, processes, materials and machines.

Acknowledgements--We particularly thank the members of our team, Hiroshi Hanada, Haym Hirsh, Eric Larkin, Soo Hong
Lee, J. C. Tsai, Charles Vann and Randy Wilson for their work on the First-Cut project. We also thank Thomas Binford,
Allan Fraser, Jean-Claude LaTombe, Peter Lindener, Dieter Mfiller and Ken Preiss for their valuable comments and advice.
Schlumberger has provided the Hyperclass programming environment and the Dynamite mini-mill for the project. The
project has also received support from the National Science Foundation and DARPA under NSF Grant DMC-8618488
and ONR 00014-88-K-0620, and the ALCOA Foundation, Computervision, Kodak, General Motors, Lockheed and SUN
Microsystems.

REFERENCES
1. J. Geddes, IBM Corporation, private communication.
2. G. Boothroyd and P. Dewhurst, Design for Assembly: A Designer's Handbook. Boothroyd Dewhurst, Wakefield, R.I.
(1983).
3. J. Newman and Krakinowski, IEEE Spectrum, pp. 50-51 (1987).
4. M. R. Cutkosky and J. M. Tenebaum, Proc. A S M E Winter A. Meet. Symp. lntell, lntegr. Manuf., Boston, Mass.,
Vol. 25, pp. 1-10 (1987).
5. M. R. Cutkosky, J. M. Tenenbaum and D. Miiller, Proc. A S M E C1E Conf., San Francisco, Calif. pp. 557-562 (1988).
6. J. M. Tenenbaum and M. R. Cutkosky, CDR Technical Report 6.1.89, Stanford University.
7. Richard F. Riesenfeld et al. Computer Science Department, University of Utah, Salt Lake City, Utah, Apr. (1987).
8. P. Balakumar et al. Carnegie-Mellon University, Pittsburgh, Pa (1988).
9. C. S. Vann and M. R. Cutkosky, Proc. A S M E USA/Jap. Symp. Flex. Automn., Minneapolis, Minn. pp. 915-922 (1988).
I0. E. Mazer, Advanced Software in Robotics (Eds A. Danthine and M. Geradin). Holland (1984).
11. VAL-H Programming Manual. Adept Technologies, San Jose, Calif. (1987).
12. CADDS User Guide, CADDS 4X Revision 3.00G Computervision Corporation, Bedford, Mass. (1987).
13. E. Soloway, Proc. 2nd Int. Conf. Human-Comput. Interact. Honolulu, Hawaii (1987).
14. D. Beach, Design Division, Stanford University, Stanford, Calif. (1986).
15. M. R. Cutkosky and S.-H. Lee, CDR Technical Report 12.15.88, Stanford University (in preparation).
16. A. K. Dewdney, J. Recreatl Math. 12, 16-20.
17. H. L. Osher and B. K. Reid, Proc. 2nd Int. Conf. Assembly Automn (1986).
18. R. Y. AI-Jaar and A. A. Desrochers, Advances in Automation and Robotics (Ed. G. N. Saridis), Vol. 2. JAI Press, Conn.
(1988).
19. S. C. Luby, J. R. Dixon and M. K. Simmons, Computers Mech. Engng, pp. 25-33 (1986).
20. S. C. Luby, J. R. Dixon and M. K. Simmons, Proc. A S M E Int. Comput. Engng Conf., Chicago, I11.Vol. 1, pp. 285-292
(1986).
21. D. L. Vickers, 1988 A S M E Comput. Engng Conf. San Francisco, Calif. (1988).
22. I. E. Sutherland, SKETCHPAD: A Man-Machine Graphical Communication System, p. 329., SJCC, Spartan Books,
Baltimore, Md (1963).
23. D. Serrano and D. Gossard, Proc. A S M E Comput. Engng Conf. Chicago, I11. (1986).
24. D. Whitney, Harvard Business Review, pp. 83-91, Jul./Aug. (1988).

UNE METHODOLOGIE ET UNE ARCHITECTURE LOGICIELLE

POUR LA CONCEPTION SIMULTANEE D'UN PRODUIT
ET DE SA FABRICATION
R~um~----Nous d~crivons une m~thodologie qui s'applique ~ la conception simultanre du produit et de
son plan de fabrication. Nous d~crivons aussi une architecture logicielle qui l'impl~mente. La m~thodolo-
gie est fond~e sur la premisse que les critdres de fabrication sont mieux servis par la conception simultan~e
d'une pidce (ou d'un assemblage de pi~x~es)et des ~tapes de sa fabrication. Le concepteur travaille en mode
fabrication, ajoutant des ~l~ments ~ l'objet en tours de conception ou manipulant directement le plan de
fabrication associ& L'architecture logicielle qui impl~mente cette m~thodologie est inspirre par le mode
de travail en ~quipe. I1 met en jeu differents experts (humains ou logiciels) qui COOl,rent pour critiquer
et amdliorer la conception depuis divers points de vue (outillage, determination de trajet d'outil,
materiaux).