What's the benefit of prohibiting the use of techniques/language constructs that have not been taught?

Question

I teach as a private tutor and most of my students are prohibited to use techniques and/or language constructs that they haven't been taught!

There's a really broad variety of stuff that is prohibited like foreach-loops, switch-statements, functions/methods, etc.

What do you think is the benefit of this rule or why do most schools and universities have such a rule?

Answer 1

Rules like this are generally instituted because the teacher is attempting to teach a concept made moot by one of these constructs. For example, as a teacher, if you're teaching bitwise operators and ask students to implement absolute value, it simply makes no sense to permit the students to use whatever library function does absolute value. You're teaching bitwise operators, and the fact that they know of the library function doesn't help them learn bitwise operators.

I believe that because you're asking here, the reason for the prohibition isn't as obvious as in my example, but my guess (without knowing the specifics of the situation) is that the prohibited constructs are not what are being taught so, for that course, the students knowledge of a more advanced concept is irrelevant to the subject matter being taught.

Answer 2

Where it stems from is, of course, because the lab is not the thing that the instructors want solved. After all, the posed lab problem is not unsolved, and your solution will only be unique (if at all) in some surface way. This is the source of the feeling that people have that the restrictions are unreasonable: they feel like solving the lab is somehow the purpose of the assignment, and therefore any high quality solution is to be praised. But, of course, that's not the point at all.

So if solving the problem isn't the deeper purpose of a lab, then what is? Typically, we are teaching an algorithm, a language feature, a data structure, or some other mental model of how something works. The lab is conjured as something that lends itself to that problem, and that is the goal of the instruction. I want to engender mastery of linked lists, or stack management, or two-dimensional arrays, or memory management, or... whatever the focus is.

The lab problem itself is entirely secondary, even if it does not in any way feel like this to the student. The problem posed to students is simply meant to provide a rich environment to play around with the learning target, and to gain some measure of experience wrestling with it.

The problem that we run into, then, is that there is no problem that cannot be solved in many ways. I can search as hard as I might for a problem that would be much, much harder to solve in a manner perpendicular to the purpose of the lab, and sometimes I will have some success. But sometimes I will not, because sometimes no such problem exists.

There exists no problem that can be solved with a linked list that cannot also be solved with an arraylist. I could provide starter code to try to force my approach, but that simultaneously increases the difficulty of creating the lab while decreasing the thought that must go into solving it.

A blanked ban, such as "you may use no bang operators in your Racket lab" is an imperfect solution, but all of the solutions are imperfect, and sometimes a ban feels like the least of the evils.

This is not a blanket defense; such bans can be careless, or needless, or clumsily done. I try hard to avoid them in my own instruction, but I don't always succeed. If it seems unfair to restrict my students' approach, it is also unfair to my students if they don't delve far enough into the course material because they originally thought of a different solution, and they just stuck with it. That keeps them on their own familiar territory and cheats them of the chance to learn the material in the course, which they may well need in their next course, or later on in their life.

Answer 3

I think that the answer of thesecretmaster is correct but let me add a bit of advice to an instructor who would do this. Just as you, the OP, wonder yourself, the rule doesn't seem to make a lot of sense and it won't make sense to students either. It may cause resentment.

So, if an instructor wants to use a rule like this then, I think that a general rule against using things not yet taught is foolish. However, you can achieve the same result by carefully stating the problem you want solved. So, for example, following thesecretmaster, instead of asking for the students to compute the absolute value ask them to compute the absolute value using only the bitwise operators. In other words, put the specific restriction into the question itself.

This brings up an important teaching and learning technique called "creativity under constraint". Some wood working artists, for example, use only hand tools, forgoing power tools. Furniture makers I've known do this. The restricted set of tools forces them to make better use of the tools that the do use, becoming more skilled in the process. But, to impose it on someone else requires that you make it clear why it is a good idea to do this.

I've discussed Creativity Under Constraint here in the past in other contexts. See this post and this other one.

Answer 4

In addition to the good reasons given in the other answers:

Sometimes students find code on the Internet that they can just copy into the assignment without understanding. In a coding class it seems reasonable to require students to understand the code they submit.

As an instructor I would consider telling students that if they use techniques not covered in class they may be required to explain these techniques to the instructor.

Answer 5

Benefit: forces students to stay with and practice required concepts of the unit/exam or subset of the course.

Answer 6

There are some great answers and discussion here about reasons why a teacher may forbid certain syntactic constructs for a given assessment. I have an additional perspective on it.

A student cannot possibly learn the entire language all at once. Not only is there syntax to learn, but also how to put the pieces together into coherent programs. It is a lot to learn for a novice programmer. So the language must be introduced incrementally, starting with basic constructs and layering more advanced ones on top of them. Whether such constructs really are more "advanced" is informed by the curriculum and pedagogy.

Some students may have more advanced knowledge. Perhaps they read ahead in the book; maybe they have had prior programming experience; it could be they saw something on Stack Overflow and they understood it. Whatever the reason, some students may have knowledge that others do not. By restricting what constructs can and cannot be used in an assignment, the instructor is leveling the playing field.

Most students are barely able to keep up with the syllabus and know only what information has been presented to them. Others may know more. The restrictions are intended to ensure that everyone is playing by the same rules. The instructor has carefully designed the assessments so they are solvable using only the concepts students are expected to have at that point in the curriculum. To some students that may feel like a straightjacket, but they need to keep in mind that most other students won't feel constrained at all because they don't know there is anything else.

Answer 7

Students need to learn how to deal with strict rules, imposed by their programming environment.

In real life, the rules are dictated by the limit of your programming language or processor. Easy example: You cannot use an instruction, that is not implemented in your microprocessor. So you need to stick to the rules of your processor.

When you now use a common programming language for teaching, you cannot teach every feature of it, so you won't hit any limitation of a language like C++. Still the student needs to be able deal with such limitations. So you for example tell the student "Implement a factorial without using the factorial function in the standard library", to impose an artificial limitation.

This seems silly, as the standard library factorial may be more optimized (e.g. using iteration when your lecture was about recursion or even optimizing on a specific processor), but later in real life, the student will encounter more complicated tasks, that are not covered by any existing library.

This requires that he learned how to implement something himself instead of always relying on existing libraries. In the end, someone build the library, when there was no existing library for this function. And this someone may be a former student of you.

Answer 8

To give a more detailed example to @thesecretmaster's answer:

Sometimes language constructs hide the underlying complexity. That might be beneficial when coding, but counterproductive when teaching. Take these loop examples:

for (int i=0; i<n; ++i) {
  // example statement
  array[i] = 5; 
}

In many languages, this can be written as a for-each loop (sometimes known under different names), such as:

for (int variable : array) {
  variable = 5;
}

The second code example makes it way harder to explain the concept of a loop invariant. Questions such as:

1. What is the last element, array[n] or array[n-1]?
2. How can you run the loop only for elements after the 3.?
3. How can you proof that the loop terminates?

become much harder to explain when students simply use the foreach feature.

Answer 9

This question was asked 3 years ago when ChatGPT didn't exist yet. Nowadays I would say (in addition to several excellent answers above) that the use of techniques not already taught is a sign that the student got some LLM to generate the answer. The answer from a chatbot can very well be correct, but it will also be more sophisticated than the student could have come up with on their own.

So you can either not allow this, or insist that the student be able to justify every single line in their code.

Answer 10

When to disallow techniques or language constructs

The primary benefit of prohibiting the use of techniques/language constructs that have not been taught yet is to have students implement somthing rather than have it implemented for them.

For example you could ask students to write code to compute the length of a null-terminated string without using any kind of built-in length method for a string class.

# memory addresses are like hotel rooms where you can store things.  
#
# reserve a hotel room and nickname the hotel room `len`  
#
# store the number zero in the hotel room nicknamed `len`
#
# for each character `ch` in string of characters `chs` { 
#     
#     if character `ch` is null {
#         stop what you are doing.
#         exit this for-loop
#         you reached the end of the loop
#     } end if statement 
#     
#     if you are reading this line, then `ch` is not NULL
#     
#     pull the number out of hotel room labeled `len`     
#
#     add one to the number in the hotel room labeled `len`
#
#     put the result back into the hotel room labeled `len`  
#
#     go back to the top of this for-loop and do it all over again. 
#
# } end for-loop 

def length(chs:str):  
    len = 0;
    for ch in chs:
        if ch == NULL:
            break; 
        len += 1
    return len

---

For-Loops

You mentioned for-loops in your original question.

If you are going to disallow for-each-loops, then I doubt you would get past writing print("Hello World").

A for-each-loop is simple enough that someone who does not know how to do any math other than addition and subtraction could write a for-each-loop.

If you have many different things (noun-like objects) which need the same task performed (verb-like objects), then a for-loop is used to verb each noun.

If you have a more than one or two cupcakes, you will need somthing like a for-loop to put frosting on top of each cupcake.

frsting = make_cream_cheese_frosting(this_sugar, this_cream_cheese); 
 
for each cupcake in cupcakes:
    cupcake.append(fsting)

for each student in students:
    students.insert(cupcake)