A divide and conquer problem solving method is a top-down method that breaks a problem into smaller parts, solves each smaller part, and combines the solution (in a bottom-up manner) to solve the original problem.

• Identify
• Define
• Design top-down, backward-chaining
• Implement bottom-up forward-chaining
• Evaluate

Fallacy: You should require beginning programming students to use top-down programming.
Problem solving in computer science is best done using top-down programming.

• top-down programming
• goal-driven programming
• backward-chaining logic

Why do many computer science programs require beginning students to do "top-down programming"?

Fallacy: One should implement a computer program in a top-down manner.
The phrase "top-down programming" is deceptive. Have you ever tried to write a program "top-down"?

Do it once and you will see that it does not work very well. The phrase "top down programming" refers to a "top-down program design" and then a "bottom-up program implementation".

Many people try to do "top down programming" by doing "top-down coding".

Some teachers who have never really used the method will teach this fallacy to their students. How would you define a "programmer"?

A top-down design insures one will get to the goal.

A bottom-up design may require extra work and may not get to the goal.

A divide and conquer problem solving method starts with a goal, here labeled "1". Assume that this problem is too complicated to be easily solved and is therefore broken into parts. Here, division by two is used.

A not-so-easy-to-read gray with red outline is used for the top-down design phase as designs often change and are not always as clear as one would like.

The problem "1" is split into two parts "2" and "3".

The problems "2" and "3" need split.

• Problem "2" is split into problems "4" and "5".
• Problem "3" is split into problems "5" and "7".

Each of problems "4", "5", "6" and "7" are split into parts.

During the top-down design, code is not written unless some prototype is needed to verify architecturally significant parts of the design.

Something is architecturally significant if not being able to do that part will cause the entire project to fail.

One tool or methodology for design is UML (Unified Modeling Language).

Why does one not see jobs advertised for UML?

The leaves of the problem are then solved.

In software engineering, unit tests are created for each leaf.

Those solutions will be worked back up the tree until the original goal is solved.

Continue composing the solutions bottom-up to solve nodes up the tree.

In software engineering, unit tests are created for each node.

Continue composing the solutions bottom-up to solve nodes up the tree.

In software engineering, unit tests are created for each node.

The solutions to each of the problems at the leaves are then passed back up the tree and combined. This is called composition.

In software engineering, unit tests are created for each node.

If anything goes wrong during the process, adjustments need to be made.

The pattern is as follows.

• Design a solution, decomposing parts top-down into smaller subproblems (down the tree).
• Implement the solution, composing parts bottom-up into solving subproblems (up the tree).

Many teachers without real world experience will often teach top-down programming to students as if one should actually do programming that way - literally.

A better way is to first design (in the head, on paper, etc.) the solution top-down and then implement that solution bottom-up. Each part of the bottom-up process has associated unit test code to test that part of the implemented solution. The entire process is called top-down programming but the actual coding process is best done bottom-up after the top-down design.

Whenever something does not work as expected during the bottom-up implementation, the design is revisited, top-down, and modified. Hopefully not too much work from the bottom needs to be changed or lost due to the changed design.

A traditional phone tree is based in this idea, though with, say, a split of more than two.

Often, a top-down problem solving method diagram has the goal at the top. This is the way a tree is often drawn in computer science but is an upside down tree in the real world (root at the top, leaves at the bottom)

The goal could be drawn at the bottom with the splits going upwards. This is still a top-down method.

• To go down the river of a river flowing north, one goes south.
• To go up the valley of a valley with lowest point in the north , one goes south.

It all depends on your point of view.

A backward chaining method starts with a goal and works backward. Just like a top-down method.

Do you see any difference in what is actually done in using a divide and conquer problem solving method?

A backward chaining method can be flipped with the goal on the right. It is still backward chaining.

People whose languages, such as Arabic and Hebrew, are read right to left, may be more comfortable with a backward chaining method drawn this way.

This happens when a sequence of events in time need to be accomplished, each before the next one can start.

It is the same idea. Here are some visualizations - topologically all the same.

Remember that top-down has to do with the direction of the arrows from the root, not the physical location based on how the tree is drawn.

The diagrams depict the decomposition. The composition is in the opposite direction.

At all times, the goal and method remains the same. It is only how the diagram is drawn that is changed.

There are many ways to depict a divide and conquer problem solving method. These method work from the root down to the leaves and include the following.

• top-down
• backward-chaining

In a similar manner, a bottom-up or forward-chaining method starts with the leaves and works towards the root - or goal, regardless of how the diagram is drawn.