<blockquote>
  <p>Minimal: 'Provide a code solution', (does not necessarily need to be
  working).</p>
  
  <p>Slightly better: 'Show how your answer works, or does not work, with
  detailed explanation and/or comments.</p>
  
  <p>Best: 'Show how you tested your solution, describe what problems you found, and how you tried to debug and fix them'.</p>
</blockquote>

<p>Awarding a large marks boost for details of testing and debugging renders SO/web copypasta answers much less useful.  Testing and debugging are absolutely essential skills when developing software, and the sooner that students practice those skills, the better for us all.</p>

<p>The number of SO posts with non-trivial code, but demonstrating no debug skills whatsoever, is embarrassing.  Too many cannot, (or will not), summon up enough programming skill to print out variables that may help diagnose a problem, never mind acually use a debugger.   Educators should be pressing home the message 'If you cannot debug, you cannot develop programs'.</p>

CC BY-SA 3.0
2017-08-26T09:43:24.957Z
2017-08-26T09:43:24.957Z
Martin James
<p>If I understand your problem correctly, it's that students can create programs that behave correctly without understanding why they behave correctly. I assume that they do this by some combination of brute force trying things and SO search.</p>

<p>Using program correctness for grading has the desirable qualities of being objective and automation friendly.</p>

<p>So how could you keep these qualities while testing for actual understanding?  While I agree that good code structure, variable naming, and possibly comments can offer proof of understanding, they are all highly subjective.</p>

<p>What I would do instead is construct exam exercises that are relatively small requirements changes to homework assignments that students have completed earlier, ideally at least 2 weeks earlier.  Then give each student access to the code (s)he submitted for the homework as a starting point for completing the exam exercises.  Tune the original homework size and the exam requirements changes so that a student who understands the code and has well-written code can complete the exam exercise quickly, but one that started from scratch would not likely be able to complete the work.
This accomplishes 4 things:</p>

<ol>
<li>It solves your original problem of testing whether students understand the code they have written.</li>
<li>It maintains the objectivity and automation friendliness of grading on program behavior.</li>
<li>It rewards production of readable, maintainable code.</li>
<li>It prepares students for the world of coding outside of a class environment, where the majority of time spent is not on isolated exercises, but extending an existing code base.</li>
</ol>

<p>Disclaimer: I work in industry and have no research to support this.</p>

CC BY-SA 3.0
2017-08-25T21:29:30.800Z
I'm also an engineer and not an instructor, but I'd be concerned about using specific homework assignments as a basis for an exam. If you have a student who struggled with the homework assignment, then they're already at a large disadvantage for the exam. Exam questions should probably stand on their own and the students are either able to answer them or unable to answer them. Instead of using the student's homework, simply provide your own program code instead.
Ellesedil
CC BY-SA 3.0
2017-08-28T14:40:54.877Z
@Ellesedil It's true that students could be punished twice for doing a bad job on homework. I would mitigate that by not making too much depend on any one piece of homework or test question. Also, you could communicate how you test ahead of time, and have office hours or class time set aside for improving homework even after it has been turned in, which would improve the code for the exam, but not for the original homework grade. Generally, I think the issue can be managed/mitigated. Using your own code would be ok sometimes, but doesn't incent students to create readable, maintainable code.
ShawnMartin
CC BY-SA 3.0
2017-08-24T20:31:13.983Z
2017-08-24T20:31:13.983Z
ShawnMartin
<p>I am wondering how much of this is because they can not express in natural language (don't know terminology). How much is because of just fiddle until it works programming.</p>

<h1>Learning to express in natural language</h1>

<p>This is important, to allow them to communicate with a larger team, to allow them to look stuff up on an internet search, and to answer some of the exam questions.</p>

<h1>Programming by fiddling / tinkering</h1>

<p>This is an important technique to use <strong>some of the time</strong>. However it should then be followed by evaluation.</p>

<p>For example: Trying to find the angle of a triangle, when drawing using turtle graphics.</p>

<ul>
<li>Made a first guess (common first guesses: 30, 60, 45, 90, 100 )

<ul>
<li>Try it.</li>
<li>Decide higher of lower (this is often decided wrong, but that is ok)</li>
<li>Guess a new value.</li>
</ul></li>
<li>repeat until you find the answer.</li>
<li>record answer with result for square.</li>
</ul>

<p>Table of angles:</p>

<pre><code>| number of sides | angle |
|-----------------|-------|
|        3        |       |
|        4        |  90   |
|        5        |       |
|        6        |       |
|        7        |       |
</code></pre>

<p>You can discuss what the best strategy is [binary search].
One you have a completed table (4 or 5 entries), you can start to look for a pattern. It there a general formula for a polygon. Also getting pupils to pretend to be the turtle can help, or teacher is turtle. In ether case another pupil is the instructor, that tells turtle to move and turn. While doing this they gain a deeper understanding of how the code works.</p>

CC BY-SA 3.0
2017-08-23T11:51:28.180Z
2017-08-23T11:51:28.180Z
ctrl-alt-delor
<p>I'm afraid my answer here will suggest that you completely revamp how you teach. </p>

<p>The sort of problems that result in issues like this, seem to me to be problems that treat the computer as a fancy calculator. Problems given to students are of the "math-y" type. Some require tricky thinking, of course, but they are unlike the sorts of problems that people in the real world write programs to solve. </p>

<p>My suggestion, is to, instead, use simulation as the basis of your teaching. There are many ways to do this, but one of the best and easiest to introduce is the <a href="http://greenfoot.org" rel="nofollow noreferrer">Greenfoot</a> system. It provides both an IDE (for Java) and a simulation framework. </p>

<p>There is also an organization for users, <a href="http://greenroom.greenfoot.org" rel="nofollow noreferrer">Greenroom</a>, who contribute simulation frameworks that you  can start with and modify. There are hundreds of such simulations, some with teaching materials, even videos. Note that the Greenroom is a membership site. You will need to join. </p>

<p>Here are a few examples. I have used some of them, but not all. </p>

<p><a href="https://greenroom.greenfoot.org/resources/261" rel="nofollow noreferrer">Create Flappy Bird Game</a></p>

<p><a href="https://greenroom.greenfoot.org/resources/248" rel="nofollow noreferrer">Fuel Depot Question</a> from APCS-A</p>

<p><a href="https://greenroom.greenfoot.org/resources/9" rel="nofollow noreferrer">Greeps - A Programming Competition</a> One of the originals. </p>

<p><a href="https://greenroom.greenfoot.org/resources/3" rel="nofollow noreferrer">Karel J Robot meets Greenfoot</a> A robot simulation - from the book. </p>

<p><a href="https://greenroom.greenfoot.org/resources/207" rel="nofollow noreferrer">2d Platformer</a> Similar to Mario. </p>

<p>There are hundreds more, both at the main Greenfoot site and the Greenroom. Only the Greenroom requires (free) membership. With these sorts of frameworks and the programming that it involves, the problem you discuss simply won't arise.  </p>

<hr>

<p>It has been noted that I often promote Greenfoot. I'm not affiliated with the site or its developers, nor have I ever been. I know some of the developers and I have produced materials for use with Greenfoot. I also occasionally submit bug reports and feature requests to the site. </p>

<p>But Greenfoot aligns well with my general teaching philosophy and makes Object-Oriented Programming easy to teach to novices in an interesting and engaging way. </p>

CC BY-SA 3.0
2017-08-23T13:15:07.390Z
2017-08-24T15:44:37.247Z
2017-08-24T15:44:37.247Z
Buffy
<p>It's time for a little "code review."  Have a student present his code in front of class and talk about how he made it work.  Hey, this happens in the professional world.  There is no time like the present to begin learning this vital skill.</p>

CC BY-SA 3.0
2017-08-25T20:54:44.277Z
@drewbenn - even if that was the case, id adds no value to someone's education to be forced to present his work in front of audience. And no, despite many claims of the opposite, you don't really do that when working as a programmer.
Davor
CC BY-SA 3.0
2017-08-26T20:54:14.820Z
@drewbenn - unfortunately cs academics drown out actual people from the industry here, so the answers you get are the same nonsense you get in the academic setting in the first place. "Democracy" has severe downsides.
Davor
CC BY-SA 3.0
2017-08-27T01:04:12.173Z
@davor Learning to present your ideas is an important skill. This often brings interesting discussion of design for programs that is both productive and useful.  NCSSM has a nice environment; kids do not have anything to fear going in front of their peers. They are used to this.
ncmathsadist
CC BY-SA 3.0
2017-08-27T09:44:10.520Z
@ncmathsadist - brushing your teeth is also an important skill, but it still doesn't belong in CS curriculum.
Davor
CC BY-SA 4.0
2022-02-03T11:33:14.133Z
It is well documented that we learn through experience, and that we often learn the most through teaching. What is lacking in many graduates is the ability for a developer to use the correct _language_ to describe their logic and issues and importantly expectations. _Talking_ about code _out-loud_ should be encouraged and practised.
Chris Schaller
CC BY-SA 4.0
2022-02-03T18:49:00.433Z
@Davor I disagree strongly. I assume we're teaching programming so that people can use the skills in a software engineering context, and in that context, being able to communicate what you're doing and why (and justifying it when challenged) is an essential skill and therefore a vital part of your education. Also, an awful lot of what I learnt about programming at college was from fellow students explaining their approach.
Michael Kay
CC BY-SA 4.0
2022-02-03T18:55:44.790Z
A technique I've also used on training courses is to actually create the code collaboratively: have someone typing while others are watching and making suggestions, asking questions, spotting problems. It doesn't fit the academic model where gaining a mark out of ten is more important than learning something useful, but as a way of getting a team of people up to speed on a new technology, it's very effective.
Michael Kay
CC BY-SA 3.0
2017-08-23T23:29:44.807Z
2017-08-23T23:29:44.807Z
ncmathsadist
<p>I have seen my share of this 'program gets output' but the programmer has no clue how she/he got there. It's funny how that happens so many times. </p>

<p>This is what I have done to at least handle the issue.</p>

<p>Before assessments, I break down the evaluation to include the following. </p>

<ul>
<li>Simply getting the output gets them the bare passing grade. </li>
<li>Those who can use meaningful names for their variables, function calls get extra.</li>
<li>Those that can back up their loops, method calls and variable declarations with expansive ( 2 to 3 lines at least) comments get extra points. </li>
<li>In addition to that, those that can write psuedocode above the program code (perhaps in a big block of comments) get some more. </li>
</ul>

<p>Obviously, this makes me their least favourite faculty in terms of evaluation and gets me a lot of complaints but I stick with it.</p>

<p>Update : Please note that, during evaluation, I don't expect all of them to be done. Say, a student is already using meaningful names everywhere, I would not mark her/him down for not writing comments. </p>

CC BY-SA 3.0
2017-08-26T10:46:10.027Z
Comments are for suggesting improvements; this conversation has been [moved to chat](http://chat.stackexchange.com/rooms/64474/discussion-on-answer-by-jay-students-can-solve-programming-exercises-but-not-exp).
thesecretmaster
CC BY-SA 3.0
2017-08-23T08:02:16.467Z
2017-08-25T08:40:19.690Z
2017-08-25T08:40:19.690Z
Jay
<p>I also encounter this issue (just encountered it yesterday in a lab exam). This is how I differentiate between someone who has done his work and just not been able to explain it and someone who has crammed/cheated:</p>

<ol>
<li><strong><em>Deleting some part of code and asking student to rewrite it</em></strong></li>
<li><strong><em>Asking student to modify a snippet of code</em></strong></li>
<li>Explain <em>this line</em></li>
</ol>

<p>Usually Point 2 is enough to differentiate. Kindly ensure to let him/her sit calmly in order to not let nerves get hold of him/her - it works for me!</p>

CC BY-SA 3.0
2017-08-25T14:13:18.223Z
I'm using the second point as the *base* for grading first-year computer science students. In the setting I usually teach, students prepare their solutions as a homework, so it's all too easy for them to just find a solution on the web; so they don't get a grade for just providing a solution that works. Most of their grade comes from implementing small modifications to their code (e.g. "Please change the order from ascending to descending" for an assignment on sorting) and bonus points for code clarity (if they can explain why; typical question is: "why is this identifier named this way?").
liori
CC BY-SA 3.0
2017-08-25T21:06:07.893Z
I got a very clear example of #1 back when I was a lab assistant.  This was in the era of floppy disks, on single drive machines  backup meant a lot of swapping.  The idiotic backup routine couldn't sense the wrong disk in the drive and someone not paying attention could easily copy the target directory over the source--deleting everything.  I knew how to rebuild them and thus got a fair number of students crying for help.  (Continued)
Loren Pechtel
CC BY-SA 3.0
2017-08-25T21:12:06.463Z
Everyone would freak when I sat them down in front of a binary dump of their data and asked them to identify it but after a bit of paging through it they would start recognizing pieces and I would build up the map I needed.  One gal absolutely couldn't get it.  Somehow it wasn't a surprise when later I found out she had copied everything.
Loren Pechtel
CC BY-SA 3.0
2017-08-23T12:33:22.070Z
2017-08-23T16:11:56.807Z
2017-08-23T16:11:56.807Z
Failed Scientist
<p>I've seen too many cases when a student has completed a programming exercise (without cheating) but can't say, for example, what type of values a variable contains during program runtime (in case of Python programs).</p>

<p>It looks like the ability to solve exercises should not be the only (or even main?) criteria for assessment.</p>

<p>Do you know any research papers (or books or posts) that tackle this issue and/or recommend other assessment techniques / exercise types?</p>

CC BY-SA 4.0
2021-01-29T18:13:44.353Z
Code with pen and paper. It might sound odd at first but solves a lot of issues. Small exercises can basically be solved by brute force. Type a few things - run - make changes - run again - fix a few conditions - run again. Use smaller exercises and let them code with pen and paper. Ignore small mistakes like a single missing semicolon or minor typos. Now you can basically see what's in the head of your students and what you need to teach/address.
wischi
CC BY-SA 3.0
2017-08-26T10:49:15.410Z
Comments are not for extended discussion; this conversation has been [moved to chat](http://chat.stackexchange.com/rooms/64475/discussion-on-question-by-aivar-students-can-solve-programming-exercises-but-not).
thesecretmaster
CC BY-SA 3.0
2017-09-10T11:12:52.370Z
IMHO, if a student can prove that their program satisfies a specification, they understand the program. Proof of correctness requires knowledge of types of values, conditions on values, and much more.
beroal
<curriculum-design><resource-request><grading><assessment>
Students can solve programming exercises but not explain their solutions. What to do?
# Students can solve programming exercises but not explain their solutions. What to do?

(Asked by: username_0 on 2017-08-23)

I've seen too many cases when a student has completed a programming exercise (without cheating) but can't say, for example, what type of values a variable contains during program runtime (in case of Python programs).

It looks like the ability to solve exercises should not be the only (or even main?) criteria for assessment.

Do you know any research papers (or books or posts) that tackle this issue and/or recommend other assessment techniques / exercise types?

**Tags:** curriculum-design, resource-request, grading, assessment

> **Comments:**
> **username_2**: Comments are not for extended discussion; this conversation has been [moved to chat](http://chat.stackexchange.com/rooms/64475/discussion-on-question-by-aivar-students-can-solve-programming-exercises-but-not).  
> **username_3**: IMHO, if a student can prove that their program satisfies a specification, they understand the program. Proof of correctness requires knowledge of types of values, conditions on values, and much more.  
> **username_1**: Code with pen and paper. It might sound odd at first but solves a lot of issues. Small exercises can basically be solved by brute force. Type a few things - run - make changes - run again - fix a few conditions - run again. Use smaller exercises and let them code with pen and paper. Ignore small mistakes like a single missing semicolon or minor typos. Now you can basically see what's in the head of your students and what you need to teach/address.  

---

## 7 answers

### Answer by username_5 on 2017-08-24. Score: 24 | Accepted answer

If I understand your problem correctly, it's that students can create programs that behave correctly without understanding why they behave correctly. I assume that they do this by some combination of brute force trying things and SO search.

Using program correctness for grading has the desirable qualities of being objective and automation friendly.

So how could you keep these qualities while testing for actual understanding? While I agree that good code structure, variable naming, and possibly comments can offer proof of understanding, they are all highly subjective.

What I would do instead is construct exam exercises that are relatively small requirements changes to homework assignments that students have completed earlier, ideally at least 2 weeks earlier. Then give each student access to the code (s)he submitted for the homework as a starting point for completing the exam exercises. Tune the original homework size and the exam requirements changes so that a student who understands the code and has well-written code can complete the exam exercise quickly, but one that started from scratch would not likely be able to complete the work.
This accomplishes 4 things:

1. It solves your original problem of testing whether students understand the code they have written.
2. It maintains the objectivity and automation friendliness of grading on program behavior.
3. It rewards production of readable, maintainable code.
4. It prepares students for the world of coding outside of a class environment, where the majority of time spent is not on isolated exercises, but extending an existing code base.

Disclaimer: I work in industry and have no research to support this.

> **Comments:**
> **username_6**: I'm also an engineer and not an instructor, but I'd be concerned about using specific homework assignments as a basis for an exam. If you have a student who struggled with the homework assignment, then they're already at a large disadvantage for the exam. Exam questions should probably stand on their own and the students are either able to answer them or unable to answer them. Instead of using the student's homework, simply provide your own program code instead.  
> **username_5**: @username_6 It's true that students could be punished twice for doing a bad job on homework. I would mitigate that by not making too much depend on any one piece of homework or test question. Also, you could communicate how you test ahead of time, and have office hours or class time set aside for improving homework even after it has been turned in, which would improve the code for the exam, but not for the original homework grade. Generally, I think the issue can be managed/mitigated. Using your own code would be ok sometimes, but doesn't incent students to create readable, maintainable code.  

---

### Answer by username_13 on 2017-08-23. Score: 31

I have seen my share of this 'program gets output' but the programmer has no clue how she/he got there. It's funny how that happens so many times.

This is what I have done to at least handle the issue.

Before assessments, I break down the evaluation to include the following.

* Simply getting the output gets them the bare passing grade.
* Those who can use meaningful names for their variables, function calls get extra.
* Those that can back up their loops, method calls and variable declarations with expansive ( 2 to 3 lines at least) comments get extra points.
* In addition to that, those that can write psuedocode above the program code (perhaps in a big block of comments) get some more.

Obviously, this makes me their least favourite faculty in terms of evaluation and gets me a lot of complaints but I stick with it.

Update : Please note that, during evaluation, I don't expect all of them to be done. Say, a student is already using meaningful names everywhere, I would not mark her/him down for not writing comments.

> **Comments:**
> **username_2**: Comments are for suggesting improvements; this conversation has been [moved to chat](http://chat.stackexchange.com/rooms/64474/discussion-on-answer-by-jay-students-can-solve-programming-exercises-but-not-exp).  

---

### Answer by username_7 on 2017-08-23. Score: 11

I am wondering how much of this is because they can not express in natural language (don't know terminology). How much is because of just fiddle until it works programming.
Learning to express in natural language
This is important, to allow them to communicate with a larger team, to allow them to look stuff up on an internet search, and to answer some of the exam questions.
Programming by fiddling / tinkering
This is an important technique to use some of the time. However it should then be followed by evaluation.
For example: Trying to find the angle of a triangle, when drawing using turtle graphics.

Made a first guess (common first guesses: 30, 60, 45, 90, 100 )


Try it.
Decide higher of lower (this is often decided wrong, but that is ok)
Guess a new value.

repeat until you find the answer.
record answer with result for square.

Table of angles:
| number of sides | angle |
|-----------------|-------|
|        3        |       |
|        4        |  90   |
|        5        |       |
|        6        |       |
|        7        |       |

You can discuss what the best strategy is [binary search].
One you have a completed table (4 or 5 entries), you can start to look for a pattern. It there a general formula for a polygon. Also getting pupils to pretend to be the turtle can help, or teacher is turtle. In ether case another pupil is the instructor, that tells turtle to move and turn. While doing this they gain a deeper understanding of how the code works.


---

### Answer by username_8 on 2017-08-23. Score: 10

I'm afraid my answer here will suggest that you completely revamp how you teach.

The sort of problems that result in issues like this, seem to me to be problems that treat the computer as a fancy calculator. Problems given to students are of the "math-y" type. Some require tricky thinking, of course, but they are unlike the sorts of problems that people in the real world write programs to solve.

My suggestion, is to, instead, use simulation as the basis of your teaching. There are many ways to do this, but one of the best and easiest to introduce is the [Greenfoot](http://greenfoot.org) system. It provides both an IDE (for Java) and a simulation framework.

There is also an organization for users, [Greenroom](http://greenroom.greenfoot.org), who contribute simulation frameworks that you can start with and modify. There are hundreds of such simulations, some with teaching materials, even videos. Note that the Greenroom is a membership site. You will need to join.

Here are a few examples. I have used some of them, but not all.

[Create Flappy Bird Game](https://greenroom.greenfoot.org/resources/261)

[Fuel Depot Question](https://greenroom.greenfoot.org/resources/248) from APCS-A

[Greeps - A Programming Competition](https://greenroom.greenfoot.org/resources/9) One of the originals.

[Karel J Robot meets Greenfoot](https://greenroom.greenfoot.org/resources/3) A robot simulation - from the book.

[2d Platformer](https://greenroom.greenfoot.org/resources/207) Similar to Mario.

There are hundreds more, both at the main Greenfoot site and the Greenroom. Only the Greenroom requires (free) membership. With these sorts of frameworks and the programming that it involves, the problem you discuss simply won't arise.

---

It has been noted that I often promote Greenfoot. I'm not affiliated with the site or its developers, nor have I ever been. I know some of the developers and I have produced materials for use with Greenfoot. I also occasionally submit bug reports and feature requests to the site.

But Greenfoot aligns well with my general teaching philosophy and makes Object-Oriented Programming easy to teach to novices in an interesting and engaging way.


---

### Answer by username_9 on 2017-08-23. Score: 9

It's time for a little "code review." Have a student present his code in front of class and talk about how he made it work. Hey, this happens in the professional world. There is no time like the present to begin learning this vital skill.

> **Comments:**
> **username_10**: @drewbenn - even if that was the case, id adds no value to someone's education to be forced to present his work in front of audience. And no, despite many claims of the opposite, you don't really do that when working as a programmer.  
> **username_10**: @drewbenn - unfortunately cs academics drown out actual people from the industry here, so the answers you get are the same nonsense you get in the academic setting in the first place. "Democracy" has severe downsides.  
> **username_9**: @davor Learning to present your ideas is an important skill. This often brings interesting discussion of design for programs that is both productive and useful.  NCSSM has a nice environment; kids do not have anything to fear going in front of their peers. They are used to this.  
> **username_10**: @username_9 - brushing your teeth is also an important skill, but it still doesn't belong in CS curriculum.  
> **username_11**: It is well documented that we learn through experience, and that we often learn the most through teaching. What is lacking in many graduates is the ability for a developer to use the correct _language_ to describe their logic and issues and importantly expectations. _Talking_ about code _out-loud_ should be encouraged and practised.  
> **username_12**: @username_10 I disagree strongly. I assume we're teaching programming so that people can use the skills in a software engineering context, and in that context, being able to communicate what you're doing and why (and justifying it when challenged) is an essential skill and therefore a vital part of your education. Also, an awful lot of what I learnt about programming at college was from fellow students explaining their approach.  
> **username_12**: A technique I've also used on training courses is to actually create the code collaboratively: have someone typing while others are watching and making suggestions, asking questions, spotting problems. It doesn't fit the academic model where gaining a mark out of ten is more important than learning something useful, but as a way of getting a team of people up to speed on a new technology, it's very effective.  

---

### Answer by username_14 on 2017-08-23. Score: 5

I also encounter this issue (just encountered it yesterday in a lab exam). This is how I differentiate between someone who has done his work and just not been able to explain it and someone who has crammed/cheated:

1. ***Deleting some part of code and asking student to rewrite it***
2. ***Asking student to modify a snippet of code***
3. Explain *this line*

Usually Point 2 is enough to differentiate. Kindly ensure to let him/her sit calmly in order to not let nerves get hold of him/her - it works for me!

> **Comments:**
> **username_15**: I'm using the second point as the *base* for grading first-year computer science students. In the setting I usually teach, students prepare their solutions as a homework, so it's all too easy for them to just find a solution on the web; so they don't get a grade for just providing a solution that works. Most of their grade comes from implementing small modifications to their code (e.g. "Please change the order from ascending to descending" for an assignment on sorting) and bonus points for code clarity (if they can explain why; typical question is: "why is this identifier named this way?").  
> **username_16**: I got a very clear example of #1 back when I was a lab assistant.  This was in the era of floppy disks, on single drive machines  backup meant a lot of swapping.  The idiotic backup routine couldn't sense the wrong disk in the drive and someone not paying attention could easily copy the target directory over the source--deleting everything.  I knew how to rebuild them and thus got a fair number of students crying for help.  (Continued)  
> **username_16**: Everyone would freak when I sat them down in front of a binary dump of their data and asked them to identify it but after a bit of paging through it they would start recognizing pieces and I would build up the map I needed.  One gal absolutely couldn't get it.  Somehow it wasn't a surprise when later I found out she had copied everything.  

---

### Answer by username_4 on 2017-08-26. Score: 2

> Minimal: 'Provide a code solution', (does not necessarily need to be
> working).
>
> Slightly better: 'Show how your answer works, or does not work, with
> detailed explanation and/or comments.
>
> Best: 'Show how you tested your solution, describe what problems you found, and how you tried to debug and fix them'.

Awarding a large marks boost for details of testing and debugging renders SO/web copypasta answers much less useful. Testing and debugging are absolutely essential skills when developing software, and the sooner that students practice those skills, the better for us all.

The number of SO posts with non-trivial code, but demonstrating no debug skills whatsoever, is embarrassing. Too many cannot, (or will not), summon up enough programming skill to print out variables that may help diagnose a problem, never mind acually use a debugger. Educators should be pressing home the message 'If you cannot debug, you cannot develop programs'.


---

