Lesson CR.7: Computational Thinking: Evaluation
Learning Objectives:
Before solutions can be programmed, it is important to make sure that it properly satisfies the problem, and that it does so efficiently. This is done through evaluation.
  • Students will learn how the evaluation of solutions is applied in computer science.
  • Students will create an algorithm for putting on a jacket on a sheet paper, and evaluate it to see if it is efficient.

Do Now: 
Watch: Computational Thinking at Google

YouTube Video




Explore: 
Read: What is evaluation?

Once a solution has been designed using computational thinking, it is important to make sure that the solution is fit for purpose. Evaluation is the process that allows us to make sure our solution does the job it has been designed to do and to think about how it could be improved. Once written, an algorithm should be checked to make sure it:
  • is easily understood – is it fully decomposed?
  • is complete – does it solve every aspect of the problem?
  • is efficient – does it solve the problem, making best use of the available resources (eg as quickly as possible/using least space)?
  • meets any design criteria we have been given
If an algorithm meets these four criteria it is likely to work well. The algorithm can then be programmed. Failure to evaluate can make it difficult to write a program. Evaluation helps to make sure that as few difficulties as possible are faced when programming the solution.

Why do we need to evaluate our solutions?

Computational thinking helps to solve problems and design a solution – an algorithm – that can be used to program a computer. However, if the solution is faulty, it may be difficult to write the program. Even worse, the finished program might not solve the problem correctly.

Evaluation allows us to consider the solution to a problem, make sure that it meets the original design criteria, produces the correct solution and is fit for purpose - before programming begins.

What happens if we don’t evaluate our solutions?

Once a solution has been decided and the algorithm designed, it can be tempting to miss out the evaluating stage and to start programming immediately. However, without evaluation any faults in the algorithm will not be picked up, and the program may not correctly solve the problem, or may not solve it in the best way.

Faults may be minor and not very important. For example, if a solution to the question ‘how to draw a cat?’ was created and this had faults, all that would be wrong is that the cat drawn might not look like a cat. However, faults can have huge – and terrible – effects, eg if the solution for an airplane autopilot had faults.

Ways that solutions can be faulty
We may find that solutions fail because:
  • it is not fully understood - we may not have properly decomposed the problem
  • it is incomplete - some parts of the problem may have been left out accidentally
  • it is inefficient – it may be too complicated or too long
  • it does not meet the original design criteria – so it is not fit for purpose
A faulty solution may include one or more of these errors.

Solutions that are not properly decomposed
If computational thinking techniques are applied to the problem of how to bake a cake, on decomposing the problem, it is necessary to know:
  • what kind of cake to bake
  • what ingredients are needed, how much of each ingredient, and when to add it
  • how many people the cake is for
  • how long to bake the cake for
  • what equipment is needed
A diagram of a further decomposition of ingredients would look like this:




At the moment, a diagram of the further decomposition of equipment would look like this:



The ‘Equipment’ part is not properly broken down (or decomposed). Therefore, if the solution - or algorithm – were created from this, baking the cake would run into problems. The algorithm would say what equipment is needed, but not how to use it, so a person could end up trying to use a knife to measure out the flour and a whisk to cut a lump of butter, for example. This would be wrong and would, of course, not work.

Ideally, then, ‘Equipment’ should be decomposed further, to state which equipment is needed and which ingredients each item is used with.


The problem occurred here because the problem of which equipment to use and which ingredients to use it with hadn’t been fully decomposed.

Solutions that are incomplete
If computational thinking techniques are applied to the problem of how to bake a cake, on decomposing the problem, it is necessary to know:
  • what kind of cake to bake
  • what ingredients are needed, how much of each ingredient, and when to add it
  • how many people the cake is for
  • how long to bake the cake for
  • what equipment is needed
However, this is incomplete – part of the problem has been left out. We still need to know:
  • where to bake the cake
  • what temperature to bake the cake at
Therefore, if this information was used to create the solution, the algorithm would say how long the cake should be baked for but it would not state that the cake should be placed in the oven, or the temperature that the oven should be. Even if the cake made it to the oven, it could end up undercooked or burnt to a cinder.

Very important factors have been left out, so the chances of making a great cake are slim.

The problem occurred here because placing the cake in the oven and specifying the oven temperature had not been included, making the solution incomplete.

Solutions that are inefficient
If computational thinking techniques are applied to the problem of how to bake a cake, on decomposing the problem, the solution would state – among other things – that certain quantities of particular ingredients are needed to make the cake. For the first ingredient, it might tell us to go the cupboard, get the ingredient, and bring it back to the table. For the second – and all other ingredients – It might tell us to do the same.

If the cake had three ingredients, that would mean three trips to the cupboard.  
While the program would work like this, it would be unnecessarily long and complicated:



It would be more efficient to fetch all the ingredients in one go, and the program would be shorter as a result:



The solution is now simpler and more efficient, and has reduced from nine steps to five. The problem occurred here because some steps were repeated.

Solutions that do not meet the original design criteria
Solutions should be evaluated against the original specification or design criteria where possible. This makes sure that the solution has not strayed too much from what was originally required, that it solves the original problem and that it is suitable for users.

Imagine having to apply computational thinking to the problem of how to bake a cake. On decomposing the problem, it is necessary to know:
  • what kind of cake to bake
  • what ingredients are needed, how much of each ingredient, and when to add it
  • how many people the cake is for
  • how long to bake the cake for
  • what equipment is needed
The first point considers what kind of cake to bake. Often, when devising solutions to problems, a specification for the design is given. For example, the cake may have to be a chocolate cake, which is still quite general, or a chocolate fudge cake with chocolate icing and flakes on top, which is more specific.

To meet the design criteria, it is important to ensure that the exactly right kind of cake is baked. Otherwise the solution may not be fit for purpose.

The problem occurred here because the solution did not meet the original design criteria – it was not exactly what was requested.

How do we evaluate our solution?

There are several ways to evaluate solutions. To be certain that the solution is correct, it is important to ask: does the solution make sense?

Do you now fully understand how to solve the problem? If you still don’t clearly know how to do something to solve our problem, go back and make sure everything has been properly decomposed. Once you know how to do everything, then our problem is thoroughly decomposed.
does the solution cover all parts of the problem?

For example, if drawing a cat, does the solution describe everything needed to draw a cat, not just eyes, a tail and fur? If not, go back and keeping adding steps to the solution until it is complete.

Does the solution ask for tasks to be repeated?
If so, is there a way to reduce repetition? Go back and remove unnecessary repetition until the solution is efficient. Once you’re happy with a solution, ask a friend to look through it. A fresh eye is often good for spotting errors.

Activity Part 2: Putting on a Jacket Evaluation
  • With a partner, have one person practice putting on a jacket as the other person tells them which steps to take. 
  • If the instructions are confusing, evaluate them as you do them, to see if you can simplify them.
  • Practice until you create a simple step-by-step procedure for putting on a jacket. 
  • Test it to see if it works by following the instructions that you wrote down.


Lesson CR.7 Wrap Up:
Reflection: Discussion
  • What is Evaluation?
  • Why is it important to evaluate?

Comments