<p>Another classification criterium would around the <em>type</em> of exercise. Some exercises are 'here is a problem, write a piece of code to solve it' or 'design a (piece of a) software system'. Others are 'here is some partial code, or code with a mistake, complete or fix it'. Another type is given correct code with the lines in randomised order, put the lines in the correct order (Parson's problems). Modifying or refactoring code are further examples. Exercises could also be presented as multiple choice questions.</p>

<p>For a blog post on these and other exercise types, see <a href="http://third-bit.com/2017/10/16/exercise-types.html" rel="nofollow noreferrer">http://third-bit.com/2017/10/16/exercise-types.html</a>.</p>

CC BY-SA 4.0
2019-08-13T19:13:09.667Z
Very nice answer.  I never knew about this resource.  What a gem!  I hope we get to hear more from you in the future.
Ben I.
CC BY-SA 4.0
2019-08-08T12:54:58.407Z
2019-08-13T13:42:14.840Z
2019-08-13T13:42:14.840Z
Lex Nederbragt
<p>In one sense this is hopeless as you probably can't come up with a classification that everyone would agree with. On the other hand, it is certainly possible for you to come up with a classification that is useful to you and to other people who think and teach like you do. </p>

<p>However, the real problem is that "what is elementary" is bound up with teaching methodology and how an instructor chooses to create and deliver a course. The danger is that people will start to think that you need to teach what a taxonomy calls elementary <em>first</em>. That may not be the best course. It implies that one can only learn computing from the lowest level (say, C) to higher levels (say, Scheme) and that is known to be false. </p>

<p>But if you are willing to match a taxonomy to a pedagogical system and deep ideas about the way that people learn, then it might be possible, even useful to do so, but, I think, it would only be valid for that system and possibly invalid for others. Just for example, tail recursion is pretty elementary if you are learning Scheme as a first language. </p>

<p>But there is also a larger issue of program structure - what you imagine the nature of computation to be. These are even more "elementary", in a certain sense, than the things you list. For example, structured programming and object oriented programming (to name just two paradigms) have very different ideas about the nature of computation, but those underlying ideas are usually implemented with the simple tools you mention (among others, which are missing). </p>

<p>In fact, using modern programming tools, it is possible to create an environment in which the student learns to program, where the environment itself defines all of the primitives, both values and actions. These environments are normally called simulations and they can be very sophisticated - Turing Complete, in fact. Any "model" of computation can be simulated this way. I point you to <a href="https://greenfoot.org" rel="nofollow noreferrer">Greenfoot</a>, for example, and it's companion teacher's site <a href="https://greenroom.greenfoot.org" rel="nofollow noreferrer">the Greenroom</a>. The latter has a large number of such simulated programming "worlds" that can be adapted to teaching novices. </p>

<p>I don't mean to discourage you, but ask you to consider that the problem is bigger than you imagine and your "solution" might only apply to a small part of the whole landscape. </p>

CC BY-SA 4.0
2019-08-05T13:57:30.687Z
Thanks for the detailed answer : I've never asked for a takeaway solution ( in the ideal world, this could be language agnostic ^^ ) I find it strange that there is nothing, even for the most used languages (Python, Java, C, etc.)
jy95
CC BY-SA 4.0
2019-08-04T22:26:01.743Z
2019-08-05T00:04:54.180Z
2019-08-05T00:04:54.180Z
Buffy
<p>For what I propose, are following types:</p>
<ul>
<li>imagine stuff in head</li>
<li>make combinations/permutations of N items, preferably in head</li>
<li>make combinations/permutations of N rules, preferably in head</li>
<li>forward reading (tracing): given code and initial values, determine result
values</li>
<li>backward reading (detective): given code and it's output, determine it's input</li>
<li>given some simple rules, generate code to solve a simple task</li>
<li><em>think of</em> and <em>build</em> database of objects in code</li>
<li>read an example algorithm: what does it do?</li>
<li>read an example program: what interesting patterns do you see?</li>
<li>solve a problem</li>
<li>write a real program</li>
</ul>
<p>Most focus on &quot;solve a problem&quot; category, as it is direct skill, but other are helpful for primary mindset education.</p>

CC BY-SA 4.0
2020-11-07T18:02:24.937Z
2020-11-07T18:02:24.937Z
danbst
<p>I wondered what attempts were made to classify programming exercises for students in their learning path, just like taxonomy in biology.
For example :</p>

<ul>
<li><p>A "concept covered" criteria from generic to specific:</p>

<ul>
<li>At level 1, we have "general" concepts : Iteration, Recursion, Abstract Data Type, Conditionals, etc.</li>
<li>At level 2, we have "less-general" concepts : For Loop, tail recursion , List, Ternary operator</li>
<li>...</li>
</ul></li>
<li><p>A "difficulty" criteria such as easy, intermediate, hard.</p></li>
</ul>

<p>According to my research on many search engines like <a href="https://dblp.uni-trier.de/" rel="nofollow noreferrer">the dblp computer science bibliography</a>, the only one that is much mentioned is Bloom's Taxonomy. </p>

<p>What are other classifications, besides that one?</p>

CC BY-SA 4.0
2019-08-09T08:41:02.507Z
Can you tell us what is ADT?
ctrl-alt-delor
CC BY-SA 4.0
2019-08-09T08:44:18.097Z
With your concept list, level 1 (general) is the hardest, to use and learn.
ctrl-alt-delor
CC BY-SA 4.0
2019-08-09T19:20:37.577Z
Abstract Data Type. My level based criteria was an example , to make the link with taxonomies in biology
jy95
CC BY-SA 4.0
2019-08-10T08:06:37.137Z
I edited you question for you (you can also do this), to make it clearer (merge part of your comment into it).
ctrl-alt-delor
<student-motivation><teaching-analogy><student-perceptions><static>
Classification of programming exercises
# Classification of programming exercises

(Asked by: username_0 on 2019-08-04)

I wondered what attempts were made to classify programming exercises for students in their learning path, just like taxonomy in biology.
For example :

* A "concept covered" criteria from generic to specific:

  + At level 1, we have "general" concepts : Iteration, Recursion, Abstract Data Type, Conditionals, etc.
  + At level 2, we have "less-general" concepts : For Loop, tail recursion , List, Ternary operator
  + ...
* A "difficulty" criteria such as easy, intermediate, hard.

According to my research on many search engines like [the dblp computer science bibliography](https://dblp.uni-trier.de/), the only one that is much mentioned is Bloom's Taxonomy.

What are other classifications, besides that one?

**Tags:** student-motivation, teaching-analogy, student-perceptions, static

> **Comments:**
> **username_1**: Can you tell us what is ADT?  
> **username_1**: With your concept list, level 1 (general) is the hardest, to use and learn.  
> **username_0**: Abstract Data Type. My level based criteria was an example , to make the link with taxonomies in biology  
> **username_1**: I edited you question for you (you can also do this), to make it clearer (merge part of your comment into it).  

---

## 3 answers

### Answer by username_2 on 2019-08-08. Score: 2

Another classification criterium would around the *type* of exercise. Some exercises are 'here is a problem, write a piece of code to solve it' or 'design a (piece of a) software system'. Others are 'here is some partial code, or code with a mistake, complete or fix it'. Another type is given correct code with the lines in randomised order, put the lines in the correct order (Parson's problems). Modifying or refactoring code are further examples. Exercises could also be presented as multiple choice questions.

For a blog post on these and other exercise types, see <http://third-bit.com/2017/10/16/exercise-types.html>.

> **Comments:**
> **username_3**: Very nice answer.  I never knew about this resource.  What a gem!  I hope we get to hear more from you in the future.  

---

### Answer by username_4 on 2019-08-04. Score: 2

In one sense this is hopeless as you probably can't come up with a classification that everyone would agree with. On the other hand, it is certainly possible for you to come up with a classification that is useful to you and to other people who think and teach like you do.

However, the real problem is that "what is elementary" is bound up with teaching methodology and how an instructor chooses to create and deliver a course. The danger is that people will start to think that you need to teach what a taxonomy calls elementary *first*. That may not be the best course. It implies that one can only learn computing from the lowest level (say, C) to higher levels (say, Scheme) and that is known to be false.

But if you are willing to match a taxonomy to a pedagogical system and deep ideas about the way that people learn, then it might be possible, even useful to do so, but, I think, it would only be valid for that system and possibly invalid for others. Just for example, tail recursion is pretty elementary if you are learning Scheme as a first language.

But there is also a larger issue of program structure - what you imagine the nature of computation to be. These are even more "elementary", in a certain sense, than the things you list. For example, structured programming and object oriented programming (to name just two paradigms) have very different ideas about the nature of computation, but those underlying ideas are usually implemented with the simple tools you mention (among others, which are missing).

In fact, using modern programming tools, it is possible to create an environment in which the student learns to program, where the environment itself defines all of the primitives, both values and actions. These environments are normally called simulations and they can be very sophisticated - Turing Complete, in fact. Any "model" of computation can be simulated this way. I point you to [Greenfoot](https://greenfoot.org), for example, and it's companion teacher's site [the Greenroom](https://greenroom.greenfoot.org). The latter has a large number of such simulated programming "worlds" that can be adapted to teaching novices.

I don't mean to discourage you, but ask you to consider that the problem is bigger than you imagine and your "solution" might only apply to a small part of the whole landscape.

> **Comments:**
> **username_0**: Thanks for the detailed answer : I've never asked for a takeaway solution ( in the ideal world, this could be language agnostic ^^ ) I find it strange that there is nothing, even for the most used languages (Python, Java, C, etc.)  

---

### Answer by username_5 on 2020-11-07. Score: 0

For what I propose, are following types:

* imagine stuff in head
* make combinations/permutations of N items, preferably in head
* make combinations/permutations of N rules, preferably in head
* forward reading (tracing): given code and initial values, determine result
  values
* backward reading (detective): given code and it's output, determine it's input
* given some simple rules, generate code to solve a simple task
* *think of* and *build* database of objects in code
* read an example algorithm: what does it do?
* read an example program: what interesting patterns do you see?
* solve a problem
* write a real program

Most focus on "solve a problem" category, as it is direct skill, but other are helpful for primary mindset education.


---

