Introduction to

Complex Problem
Solving
RIPHAH SCHOOL OF COMPUTING AND INNOVATION
(RSCI)
The 6-Step Problem Solving
Framework
Problem Solving is the sequential process of analyzing information related to a given situation and
generating appropriate response options. There are 6 steps that you should follow to solve a
problem:
1. Understand the Problem
2. Formulate a Model
3. Develop an Algorithm
4. Write the Program
5. Test the Program
6. Evaluate the Solution
STEP 1: Understand the
Problem:
It sounds strange, but the first step to solving any problem is to make sure that you understand the
problem that you are trying to solve. You need to know:
o What input data/information is available ?
o What does it represent ?
o What format is it in ?
o Is anything missing ?
o Do I have everything that I need ?
o What output information am I trying to produce ?
o What do I want the result to look like … text, a picture, a graph … ?
o What am I going to have to compute ?
Example: Calculate the average
grade for all students in a class.
In our example, we well understand that the input is a bunch of grades. But we need to understand
the format of the grades. Each grade might be a number from 0 to 100 or it may be a letter grade
from A+ to F. If it is a number, the grade might be a whole integer like 73 or it may be a real number
like 73.42. We need to understand the format of the grades in order to solve the problem.
We also need to consider missing grades. What if we do not have the grade for every student (e.g.,
some were away during the test)?
Do we want to be able to include that person in our average (i.e., they received 0) or ignore them
when computing the average?
We also need to understand what the output should be. Again, there is a formatting issue. Should we
output a whole or real number or a letter grade ?
Maybe we want to display a pie chart with the average grade. It is our choice. Finally, we should
understand the kind of processing that needs to be performed on the data. This leads to the next
step.
STEP 2: Formulate a Model:
Now we need to understand the processing part of the problem. Many problems break down
into smaller problems that require some kind of simple mathematical computations in order to
process the data. In our example, we are going to compute the average of the incoming grades.
So, we need to know the model (or formula) for computing the average of a bunch of numbers.
If there is no such “formula”, we need to develop one. Often, however, the problem breaks
down into simple computations that we well understand. Sometimes, we can look up certain
formulas in a book or online if we get stuck.
Continue…
In order to come up with a model, we need to fully understand the information available to us.
Assuming that the input data is a bunch of integers or real numbers
x1,x2,…,xn representing a grade percentage, we can use the following computational model:
Average1 = (x1 + x2 + x3 + … + xn) / n
STEP 3: Develop an Algorithm
Now that we understand the problem and have formulated a model, it is time to come up with a
precise plan of what we want the computer to do. An algorithm is a precise sequence of
instructions for solving a problem
STEP 4: Write the Program:
Now that we have a precise set of steps for solving the problem, most of the hard work has been
done. We now have to transform the algorithm from step 3 into a set of instructions that can be
understood by the computer. Writing a program is often called "writing code" or “implementing
an algorithm”. So the code (or source code) is actually the program itself.
STEP 5: Test the Program
Once you have a program written that compiles, you need to make sure that it solves the
problem that it was intended to solve and that the solutions are correct.
Running a program is the process of telling the computer to evaluate the compiled
instructions.
When you run your program, if all is well, you should see the correct output. It is possible
however, that your program works correctly for some set of data input but not for all. If the
output of your program is incorrect, it is possible that you did not convert your algorithm
properly into a proper program. It is also possible that you did not produce a proper algorithm
back in step 3 that handles all situations that could arise. Maybe you performed some
instructions out of sequence. Whatever happened, such problems with your program are known
as bugs. Bugs are problems/errors with a program that cause it to stop working or produce
incorrect or undesirable results.
Continue…
You should fix as many bugs in your program as you can find. To find bugs effectively, you should
test your program with many test cases (called a test suite).
It is also a good idea to have others test your program because they may think up situations or
input data that you may never have thought of.
The process of finding and fixing errors in your code is called debugging and it is often a very
time-consuming.
STEP 6: Evaluate the Solution:
Once your program produces a result that seems correct, you need to re-consider the original
problem and make sure that the answer is formatted into a proper solution to the problem. It is
often the case that you realize that your program solution does not solve the problem the way
that you wanted it to. You may realize that more steps are involved.
What are Complex Problems?
1. The complexity of a system may be defined as the number of elements and relations of the
system (see Funke, 1985). As stated, “the complexity of a domain of reality is the higher, the
more features there are and the more these features are interdependent”
2. A problem is considered to exist, “when a living creature has a goal but does not know how
this goal is to be reached. Whenever one cannot go from the given situation to the desired
situation simply by action, then there has to be recourse to thinking” (Duncker, 1945, p.1).
Dörner has gone into more detail when he emphasized that ”barriers“ between the given
situation and the desired goal state, i.e., the lack of knowledge, can be further classified
according to the amount of (a) ignorance of the means/operators applicable, and (b) lack of
concreteness concerning the goal state (see Dörner, 1976, or Funke, 2003).
3. Problem solving can be defined as successfully searching for an operation or a series of
operations in order to transfer the given actual state of the system to a goal state (Newell &
Simon, 1972; Dunbar, 1998).
Characteristics of complex
problems
Changing over time
Multiple stakeholders with different goals whose decisions and actions impact each other –
Time delays between action and result –
Unintended Consequences of Short-Term Solutions
Accumulations and history dependence
Changing over time (dynamic)
The problems we are solving today look different than they did yesterday and will look different
tomorrow.
staff are hired and leave; parents’ priorities change; policies are enacted and revised; the
curriculum is introduced and replaced; and communities grow and change. All components of
education systems change over time, so we must think about these factors as dynamic rather
than static.
Multiple stakeholders with
different goals
Administrators, teachers, students, parents, and teachers are experiencing systems differently,
therefore have different incentives and motivations. The district’s goal in mandating a school-
wide curriculum to improve test scores may conflict with the teacher’s goal to meet the
individual needs of each student.
Time delays between action and
result
Despite our desire to see instant results, there is a lag time between our actions and their
impacts. An investment in early childhood education will take years to improve graduation rates.
An investment in a relationship with a child today won’t instantaneously transform the school’s
culture. Often funding or buy-in is gone long before an initiative can demonstrate impact.
Unintended Consequences of
Short-Term Solutions
When we can’t see or understand the system as a whole, our well-intentioned actions may have
side effects that make the problem worse in the long-run. Let’s say our district has low test
scores, so we double down on time spent preparing for standardized tests. In the short term,
test scores may improve. But there is an unintended consequence: with the added pressure on
testing, teachers become burnt out and students become less engaged in learning. Ultimately,
the test scores drop further
Accumulations and history
dependence
The behavior of a system is not only influenced by what is going on right at this moment, but the
history of accumulated experiences of people in that system. A high school parent outreach
coordinator may initiate large scale listening sessions and free brunches to build relationships
with parents, but parents’ perceptions and experience of the school may be influenced by the
accumulated positive and negative experiences over years of interacting with the school -- both
as a parent but also as a student themselves