An experiment was conducted to investigate the relative contributions of syntactic form and content to conditional reasoning. The content domain chosen was that of causation. Conditional statements that described causal relationships (if

The creation of plan schemes is examined in a naturalistic, longitudinal study of problem solving. Ten novice programmers each wrote eight Pascal programs to solve a series of problems. Their protocols were analyzed to determine how declarative programming knowledge was used to create simple procedural program plans, and how the simple plans were used to create complex plans. Plan creation showed a process of backward development, from the goal to the plan focus, that port of the plan that directly implements the goal. Once defined; it is expanded to create the complete plan, showing backward development of plan parts from the focus. Once the plan is complete, it may be stored as a plan schema and retrieved in subsequent problem solving. The plan will then show forward development as it is implemented in schema order, the order in which plan pieces occur in the finished program. The change from backward development during creation to forward development after retrieval was strongly evident in the statistical analysis of the protocol data. Previous studies of novice programming, which showed only forward development, ore explained as special cases of this more general model, cases in which schema knowledge was available to the problem solver.

This article models program design as a process of search through the program structure. Some of this structure is captured in the final program code, but much of the fine structure is impIicit in the design process and is not apparent in the final artifact. Viewed from a procedural perspective, a program consists of a set of roles connected by linear order; this is the way a serial computer views a program. Viewed from a functional perspective, a program consists of a set of actions connected by data and control flow dependencies, so they define a nonlinear plan that can be used by a parallel machine. A person sees a program as a set of nodes connected through their data flow, control flow, or Iinear order. Nodes occur at many Ieveis of description, from the most basic concrete node that corresponds to a line of code, up to an abstract node that may consist of one or more routines of arbitrary size.My thanks to Clayton Lewis for pieces of the puzzle, and to the reviewers for their excellent comments. The model owes a great debt to the work of

Program design, from initial idea to executable code, was studied in a group of novice (first programming course) and a group of intermediate (second course) student programmers. The approach of the intermediate students could usually be described as forward and top-down design, but the behavior of the novices could not be so easily captured.Top-down design depends on both the expertise of the programmer and the difficulty of the problem. When faced with a difficult problem, even the expert has to build up a solution from simple pieces. In the approach adopted here, top-down design is based on the refinement of a known solution or schema that is retrieved and expanded at progressively greater levels of detail. If the expert knows all the required abstract and detailed schemas, then the design shows a pattern of top-down and forward expansion at all levels. When a schema cannot be retrieved and has to be created, top-down design breaks down and is replaced by bottom-up design. At the extreme, a rank novice has to create all the required plans, and design then shows consistent bottom-up and backward solution development.Separating plan retrieval from plan creation has three important conse-

No abstract