Stages of Teaching Programming Skills

Nowadays, many programmers are involved in creating educational content, teaching, and mentoring alongside their main jobs. Teaching software development has become a new mainstream, requiring a large number of educators. However, the problem is that programmers generally do not know how to teach others. I have experience as both a programmer and an instructional designer, and in this article, I want to talk about the stages of learning any new skill in programming. Overall, these stages are universal and can be applied to any field, but the examples in the article will be dedicated to programming.

1. Introduction to Skills

1.1 Skill

A skill is the ability to perform certain actions to achieve a specified result or solve a problem. In terms of programming, a skill can be both the overall ability to program and the ability to perform a small operation, such as declaring a variable, finding an element index in an array, etc. The complexity of skills varies in this context. The ability to program is a very complex skill consisting of many smaller skills. In contrast, declaring a variable is a simple, small skill that hardly requires other programming skills.

1.2 Action Algorithm and Knowledge

Any skill (whether more complex or less) is expressed in some action algorithm that needs to be performed to achieve the result. For example, to declare a variable in JavaScript, one needs to:

• Choose a keyword: var, const, or let;
• Select a valid variable name;
• Use the assignment operator “=”;
• Specify the variable’s value according to the rules of the data type. For example, strings should be in quotes, floating-point numbers should be written with a dot, arrays should be in square brackets with elements separated by commas, etc.

Executing the action algorithm is inseparable from the knowledge of the subject area. For the algorithm above, one needs to know the differences between the keywords var, const, and let, the basic rules for naming variables, the assignment operator, the syntax for different data types, and so on.

1.3 Awareness of Skill Application

One may not have all this knowledge at a high level to declare a variable. For example, a student might simply remember that the teacher used English words for variables: age, count, res, and use similar words in tasks. However, the student might not remember any rules for naming variables and might try to name variables with just numbers.

Using the variable example, we approach the awareness of skill application. Awareness of skill application is the ability of a student to correlate the actions of performing a skill with the knowledge of the subject area. The more knowledge about the subject area and the better the student correlates it with actions, the higher the awareness of skill application and the correctness of actions. Teachers should always remember that externally a student might demonstrate skill mastery, but the awareness of performed actions might be low. In a different task context, such a student will fail to apply the skill. Therefore, it’s important not only to solve tasks but also to ask students to verbalize their solution process and justify their actions. It’s better to solve fewer tasks but to work through them more deeply.

1.4 Complex Skills

The more complex the skills we deal with, the more actions there are in the algorithm, the more variability of these actions, and the more knowledge of the subject area is required to choose the correct actions. For instance, when writing a simple application, like a ToDo List, the student will not only need to write code consciously but also structure their work, break it down into stages, and think ahead. Here, the problem often arises that students do not know where to start, how to build a sequence of steps to the result. In such cases, live coding is invaluable in teaching, where the teacher shows how a program is created from scratch dynamically.

2. Stages of Teaching Programming Skills

Let’s consider the stages of teaching programming skills to a student.

2.1 Knowledge Transfer

First of all, we convey to the student the necessary knowledge to apply the skill and show how the action algorithm is performed to achieve the skill result.

Formats commonly used for knowledge transfer include:

• Lecture/Talk — Conceptual explanation of the theory: what certain concepts, principles mean, etc. For example, what is a variable, how the for loop conceptually works, what is the DOM, etc.
• Live Coding — Demonstration of skill application with an explanation of the meaning of each action. Demonstration of variable declaration, array elements output to the console using a for loop, getting a DOM element value, etc.
• Analysis of Ready Examples — Analysis of various code combinations so that students better understand how to adapt the skill to different situations.

Teachers usually handle this stage well. Common mistakes here include filling the entire lesson time or most of it with knowledge transfer. It’s important to know when to stop, highlight the main points, and move on to the next stages.

2.2 Knowledge Acquisition

The fact that we have conveyed knowledge to students does not mean that they have perceived and assimilated it. By transferring knowledge, we have just placed some material in the student’s mouth. Now we need to stimulate the student to assimilate this material.

Methods to provoke knowledge acquisition include:

• Retelling — Initially, simply stimulate students to retell what they heard from the teacher. For example, “Explain how the useEffect hook works in React?” and continue with questions that just make students recall the material. “What are its components?”, “What functionality should be placed in this hook?”
• Understanding Questions — When students can at least retell the material, move on to questions requiring deeper thinking and understanding of the topic. For example, “What will happen to the component if useEffect is written without a dependency array?” or questions integrating new knowledge with other knowledge, like “How does the execution of useEffect fit into the component’s lifecycle?”
• Explaining Code Examples, Predicting Code Output — Similar to the teacher’s code analysis during the knowledge transfer stage, here students explain the code and predict its result based on their understanding.

This stage does not end knowledge acquisition. During practical work, students will further supplement and clarify their understanding of the subject area. However, before diving into practical work, where students will face not only understanding problems but also correct syntax when writing code, it’s better if they simply talk through the steps of working with a new programming construct.

In reality, teachers often wait for questions from students. Usually, they don’t have questions. This, of course, doesn’t mean everything is clear. Students simply don’t know how to analyze their knowledge and ask questions. Hence, this stage requires a proactive stance from the teacher.

Even with a proactive teacher and their questions, it may not always result in a useful dialogue. For example, if the group is inactive and contact with students is not established. In such cases, do not get stuck at this stage but return to it periodically during conscious decision-making work.

2.3 Skill Formation

The previous stage of knowledge acquisition is just a prerequisite for starting skill formation. As mentioned earlier, a skill is the ability to apply and adapt an action algorithm to solve a problem. The more complex the skill, the longer the action chain it implies and the more conditions affect each action’s execution.

Skill formation can be compared to how children learn to walk. Initially, they observe adults walking (knowledge transfer and acquisition). However, this doesn’t mean children immediately stand up and walk. At first, they need support, opportunities to take a limited number of steps, etc. Gradually, the child’s muscles strengthen, they start feeling balance better, and consequently walk longer distances until they can walk freely.

Similarly, in programming skills acquisition, students see the teacher writing code, explaining it, and perhaps can even interpret it themselves. But this doesn’t mean they can immediately program independently. It’s essential to gradually lead students to independent programming and problem-solving, gradually transferring more control over the task. Here are two main methods to achieve this:

• Solving Problems with the Teacher’s Help — For example, you publicly offer one student in the group to solve a problem and guide them to the correct solution with questions and hints. Then take another student with another problem and gradually reduce the number of hints. Engage the rest of the group in participating in the solution.
• Problems with Partially Completed Solutions — This method smoothly leads students to independent problem-solving. You provide problems where part of the code is already written, but some steps (lines of code) are missing. These steps can vary in different problems, so students work through different elements of the code. To solve the problem, students need to understand the existing code and write the missing parts. Gradually, the volume of the ready code decreases, and the amount of code to be written increases.
• Team-Based Problem Solving — In this approach, students mainly help each other. The strength of this approach lies in students freely discussing and verbalizing their work, seeing how differently the same information from the teacher is perceived, and thus delving deeper into the topic. The teacher can play the role of a coach, periodically intervening in the team’s work to guide it in the right direction or make it more active. For the teacher, the advantage of student teamwork over individual work is that they can observe how students reason. Based on this information, the teacher can better explain and guide students.

Initially, to support skill formation, it’s important that the syntax of the constructs being studied is always visible to the student. It’s quite difficult to remember it immediately, so getting stuck on it can become an obstacle for the student to a more general and deeper understanding of the meaning of the constructs being studied. Syntax examples in plain sight will help the student focus more on understanding the meaning.

Gradual reduction of support leads us to the complete independent problem-solving by students. An important part of the teacher’s skill lies in building an optimal path for reducing this support. In some topics, this path should be short, while in others it should include more intermediate steps (problems with support).

During skill formation, several educational processes occur:

• Reducing support from the teacher;
• Increasing the requirements for conscious problem-solving: more reasoned explanations, finding gaps and errors in students’ knowledge;
• Increasing the complexity of tasks (longer problem-solving algorithms, using rarer knowledge);

At this stage, many teachers find it difficult to build a gradual process of reducing student support. Most often, if lesson time isn’t entirely spent on knowledge transfer and there is practice, there is a sharp transition from knowledge transfer to independent problem-solving by students. Some students are not ready for this and thus disengage from the lesson. It’s worth paying attention to the presence of intermediate tasks with support before transitioning students to independent problem-solving.

2.4 Application and Integration of Skills

When students have learned to solve small isolated problems using the studied skill, it is necessary to gradually expand the context of the tasks. Provide more complex tasks requiring the application of not only the studied constructs but also other previously covered constructs/concepts of programming. In the example with useEffect, you can suggest students write a program that uses the previously covered useState, useRef, rendering an array in JSX, etc.

At the same time, don’t underestimate the complexity of such tasks for students. The fact that only previously studied constructs will be used often makes such tasks seem simple for students, and sometimes they are even abandoned due to the higher priority of studying a new topic. However, the integration and joint use of multiple skills is a separate complex educational task. Students can fairly well apply studied constructs individually, but at the same time be unable to write complex programs. Considering that the ultimate goal of programming education is solving business problems requiring the combined use of a wide range of skills, integration is an important step in learning that should not be skipped or left until the end of the course.

Regarding difficulties for teachers at this stage, those who reach such integrated practice may not always have enough time for it, given the slow programming speed of students. A common misconception is the belief that for integration, a large complex project at the end is sufficient. This is not the case; regular “continuous integration” is needed.

2.5 Assessment and Reflection

Assessment

Assessment takes place throughout the entire lesson. The teacher should constantly correlate the course of their narration, proposed activities, and tasks with how well students are mastering new knowledge and skills. However, by the end of the lesson or the end of the topic study, more attention should be paid to assessment to form a clear understanding of students’ capabilities:

• What students know/understand, what they are familiar with from what has been covered.
• What they can write, what problems they can solve.
• Whether they can integrate acquired skills into the context of more complex tasks.

During assessment, you should primarily rely on observations:

• You asked something and students answered reasoned.
• You gave students tasks or more complex projects, and they solved them on their own.

Here, there is a strong temptation to follow the path: “well, I told them this,” “we analyzed such an example,” so they should know, be able, etc. That is, evaluating students based on what you, as a teacher, said, showed, wrote, rather than what the students themselves did. At the assessment stage, it’s not about what students should be able to do, but what they can actually do. This seems obvious, but misconceptions occur in 3 out of 4 cases.

Overall, assessing students’ knowledge during the lesson is one of the most difficult and non-obvious tasks for a teacher. On one hand, you can’t get into everyone’s head. On the other hand, a poor understanding of students’ capabilities correlates with a lecture style of teaching. In such a case, during the lesson, there are simply not enough activities where students can show themselves, and the teacher can form an idea of the students’ level based on observations of their work.

Incorrect assessment or its complete absence gradually leads to a growing gap between the teacher and students. Students understand the lessons less and participate less, find it increasingly difficult to formulate specific questions, most of them withdraw, and a smaller part becomes more aggressive. Correcting such a situation again begins with assessing students to form a clear picture of the real state of things: students’ real knowledge and abilities, from which to proceed when conducting lessons.

Reflection

Reflection here refers to the student’s self-assessment or the student’s understanding of their knowledge, skills, and abilities. This is a separate soft skill that is poorly developed in most students.

During lessons, it is advisable to stimulate students to reflect on what they understood, what they can write, and what problems they can solve. Ask simple questions, for example:

• What do you feel confident about, and what do you not understand in the new topic?
• What seems illogical or confusing in the new topic?
• Imagine what problems you could solve with your current understanding of the topic? Think about when difficulties might arise.

Here, complex questions are not needed. Regular work with reflection will help find the most effective questions for your group of students. However, 90% of the success of reflection depends on the atmosphere: how much students trust the teacher, how emotionally safe it seems to show misunderstanding, etc.

2.6 Reinforcement

Even forming a simple skill rarely confines to one lesson. Especially if we are talking about a sustainable skill that will stay with the student for a long time and can be consciously applied in different contexts. Unfortunately, our processes of forming neural connections are not so fast and straightforward. Therefore, repeated regular practice is important, during which the student accumulates a large amount of practice performing the target action algorithm as well as many different contexts of skill application.

Repeated regular practice does not mean solving problems on all covered topics in every lesson. This is excessive and not feasible in terms of time. On the contrary, over time, the intervals between repetitions should increase.

Reinforcement will occur naturally if, when studying new topics, the teacher regularly goes through the Application and Integration stage with students, which involves solving complex problems including not only the new studied construct but also previously covered topics. Here, it’s important to monitor oneself not to give similar tasks constantly using arrays and the for loop, but too rarely using objects and the while loop. When coming up with integration tasks, just ask yourself what we haven’t used for a long time from the previously studied material?

2.7 Working with Skill Formation Stages

The learning process is not linear. You can repeatedly return to certain stages. Some stages run parallel to others (e.g., knowledge acquisition, assessment, and reflection). It’s not always necessary to go through all stages. However, having an understanding of the skill formation process is useful. Analyzing conducted lessons and these stages can help better understand students’ problems with skill formation in programming.