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, the only one that is much mentioned is Bloom's Taxonomy.

What are other classifications, besides that one?

  • $\begingroup$ Can you tell us what is ADT? $\endgroup$ – ctrl-alt-delor Aug 9 '19 at 8:41
  • $\begingroup$ With your concept list, level 1 (general) is the hardest, to use and learn. $\endgroup$ – ctrl-alt-delor Aug 9 '19 at 8:44
  • $\begingroup$ Abstract Data Type. My level based criteria was an example , to make the link with taxonomies in biology $\endgroup$ – jy95 Aug 9 '19 at 19:20
  • $\begingroup$ I edited you question for you (you can also do this), to make it clearer (merge part of your comment into it). $\endgroup$ – ctrl-alt-delor Aug 10 '19 at 8:06

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, for example, and it's companion teacher's site the Greenroom. 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.

| improve this answer | |
  • $\begingroup$ 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.) $\endgroup$ – jy95 Aug 5 '19 at 13:57

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.

| improve this answer | |
  • $\begingroup$ Very nice answer. I never knew about this resource. What a gem! I hope we get to hear more from you in the future. $\endgroup$ – Ben I. Aug 13 '19 at 19:13

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.

| improve this answer | |

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy

Not the answer you're looking for? Browse other questions tagged or ask your own question.