Stages of developing programming skills
Nowadays, many programmers are engaged in authoring educational content, teaching, and mentoring in addition to their main job. Software development training has become a new mainstream and it requires a large number of teachers. But the problem is that programmers, as a rule, do not know how to teach other people. 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 programming skill. In general, these stages are universal and can be applied to any field, but the examples in the article will be devoted to programming.
Structure of the article
Dive into skills
1.1 Skill
1.2 Algorithm of actions and knowledge
1.3 Awareness of skill application
1.4 Complex skillsStages of skill development
2.1 Knowledge Transfer
2.2 Knowledge acquisition
2.3 Skill development
2.4 Application and integration of skill
2.5 Assessment and reflection
2.6 Reinforcing the skill
1. Dive into skills
1.1 Skill
A skill is the ability to perform certain actions to achieve a given result or solve a problem. In relation to programming, a skill can be called both the ability to program in general and the ability to perform some small operation, for example, to declare a variable, find the index of an element in an array, etc. In this case, the complexity of skills differs. The ability to program is a very complex skill, consisting of many smaller skills. And the ability to declare a variable, on the contrary, is a simple, small skill that practically does not require other programming skills.
1.2 Algorithm of actions and knowledge
Any skill (both more complex and less) is expressed in some algorithm of actions that must be performed to achieve a result. For example, in order to declare a variable in JavaScript, you need to:
Choose the keyword var, const or let;
Select a valid variable name;
Put the assignment operator “=”;
Specify the value of the variable in accordance with the rules of the data type to which the value belongs. For example, put a string in quotation marks, write a fractional number through a period, put an array in square brackets, and separate the elements with a comma, etc.
The execution of the algorithm of actions is inextricably linked with knowledge of how the subject area is structured. So for the algorithm above, you need to know the differences between the keywords var, const and let, know the basic rules for naming variables and the assignment operator, know the syntax for recording various data types, etc.
1.3 Awareness of skill application
You may not have all this knowledge at a high level to declare a variable. For example, a student simply remembers that the teacher called variables by English words: age, count, res and uses similar words when solving problems. But at the same time, the student may not remember a single rule for naming variables and, on occasion, will try to designate variables simply by numbers.
Using the variable example, we approached the awareness of skill application. Awareness of skill application is the student's ability to correlate actions to perform a skill with 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 the actions. The teacher should always remember that a student may outwardly demonstrate mastery of a skill, but at the same time the awareness of the actions performed may be low. If the context of the task changes, such a student will not cope with the application of the skill. Therefore, it is so important not only to solve problems, but also to ask students to voice the solution process, to justify the actions performed. In this case, it is better to solve fewer problems, but to work through them more deeply.
1.4 Complex skills
The more complex the skills we are dealing with, the greater the number of actions in the algorithm, the greater the variability of these actions, the greater the requirements for knowledge of the subject area in order to choose the right actions. So, when writing a simple application, for example, ToDo List, a student will face not only the need to consciously write code, but also to structure their work, divide it into stages, think several steps ahead. Here, the problem often appears that students do not know where to start, how to build a sequence of steps to the result. In such cases, live coding is indispensable in training, when the teacher shows in dynamics how a program is created out of nothing.
2. Stages of skill formation
Let's look at the stages of skill development in a student.
2.1 Knowledge Transfer
First of all, we provide the student with the knowledge necessary to apply the skill and show how the algorithm of actions is carried out to achieve the result of the skill.
The following formats are commonly used to transfer knowledge:
A story/lecture is a conceptual explanation of a theory: what certain concepts, principles, etc. mean. For example, what a variable is, how the for loop conceptually works, what DOM is, etc.
Livecoding is a demonstration of the use of a skill with an explanation of the meaning of each action. Demonstration of variable declaration, console output of array elements using a for loop, obtaining the value of a DOM element, etc.
Reviewing ready-made examples – reviewing different combinations of code so that students better understand how to adapt the skill to different situations.
Teachers usually do a good job of this stage. Among the mistakes that occur here is filling the entire lesson or most of it with knowledge transfer. You need to be able to stop in time, highlight the main points and move on to the next stages.
2.2 Knowledge Acquisition
The fact that we have transmitted knowledge to students does not mean that they have perceived and assimilated it. By transmitting knowledge, we have simply put some material into the student's mouth. Now we need to stimulate the student to assimilate this material.
To stimulate the acquisition of knowledge, the following methods are suitable:
Retelling. At the first stage, you can simply encourage students to retell what they heard from the teacher. For example, tell me how the useEffect hook works in React? And then continue with questions that simply make students remember the material. What components does it consist of? What functionality should be placed in this hook?
Comprehension questions. Once students have at least been able to retell the material, it is necessary to move on to questions that will require students to think about the material more deeply and, accordingly, understand the topic, for example: What will happen to the component if useEffect is written without an array with dependencies? Or questions on integrating new knowledge with other knowledge, for example, how does the execution of useEffect fit into the component's life cycle?
Explaining code examples, what the code will output – similar to the analysis of code from the teacher at the knowledge transfer stage, here the students explain the code and also predict its result based on their understanding of its operation.
The acquisition of knowledge is not limited to this stage. Further, during the practical work, students will supplement and clarify their understanding of how the subject area is structured. However, before diving into this very practical work, where students will encounter not only problems of understanding, but also of the correct syntax when writing code, it is better for them to simply talk through the procedure for working with a new programming structure.
If we talk about the real situation in the classroom, then here teachers often wait for questions from students. And they usually have no questions. This, of course, does not mean that everything is clear. Students simply do not know how to analyze their knowledge and ask questions. Therefore, this stage requires a proactive position of the teacher.
In turn, even with a proactive position of the teacher and asking them questions, a useful dialogue may not always result. For example, the group is completely inactive and it is not possible to establish contact with the students. In this case, you should not get hung up on this stage, but in the future, periodically return to it in the process of working with awareness of the solution.
2.3. Skill Formation
The previous stage of learning is only a prerequisite for starting to form a skill. As previously stated, a skill consists of the ability to apply and adapt to the context an algorithm of action to solve a problem. The more complex a skill is, the longer the chain of actions it assumes and the more conditions the execution of each action depends on.
The formation of the skill can be compared to how children learn to walk. At first, they see a lot of how adults walk (transmission and assimilation of knowledge). However, this does not lead to children immediately getting up and walking. At first, they need to be supported, given the opportunity to take a limited number of steps, etc. Gradually, the child's muscles become stronger, he begins to feel balance better and, as a result, walk an increasingly longer distance until he begins to walk freely.
The same goes for learning programming skills: students see how the teacher writes code, explains it, and perhaps can even interpret it themselves, but this does not mean that they can immediately program freely themselves. It is necessary to smoothly lead students to independent programming and problem solving, gradually transferring more and more control over the solution of the problem. Here are two main methods of how this can be done:
Solving problems with the help of a teacher. For example, you offer to solve a problem publicly to one of the students in the group and with the help of questions and hints direct him to the correct solution. Then take another student and another problem and gradually reduce the number of hints. Involve the rest of the group more in participating in the solution.
Solving problems where part of the solution already exists (completion problems). This is another way to smoothly lead students to completely independent problem solving. In this case, you give problems where the solution code is already partially written, but some steps (some lines of code) are missing. And these can be different steps in several problems, so that students will work through different elements of the code. To solve the problem, students need to understand the existing code and write the missing one. Gradually, the amount of ready code decreases, and the amount of code that needs to be written increases.
Solving a problem by a team of students. In this approach, students mainly help each other. The strength of this approach is that students can freely, without the pressure of the teacher's authority, discuss and talk about the progress of their work, see how different students perceived the same information from the teacher differently, and thus delve deeper into the topic. The teacher can play the role of a coach here, periodically intervening in the team's decision to direct it in the right direction or simply make it more active. For the teacher, the advantages of teamwork over individual work of students also lie in the fact that he can see from the outside how the students reason. And then, based on this information, it is better to explain and prompt the students.
Initially, as a support in skill formation, it is important that the syntax of the studied constructions is always visible to the student. It is quite difficult to remember it right away, so a hitch with it can become an obstacle for the student to a more general and deep understanding of the meaning of the studied constructions. Examples of syntax in sight will help the student to focus more on understanding the meaning.
Gradually decreasing support leads us to students solving problems completely independently. An important part of the teacher's skill is to build an optimal path to decreasing this support. In some topics, this path should be short, and in others, it should include more intermediate steps (problems with support).
During the development of a skill, several learning processes occur:
Decreased support from the teacher;
Increasing the requirements for awareness of the decision: more reasoned explanation, search for gaps and errors in students’ knowledge;
Increase in the complexity of problems (longer solution algorithm, use of rarer knowledge);
At this stage, it is difficult for many teachers to build a gradual process of reducing student support. Most often, if the entire lesson time is not spent on knowledge transfer and there is practice, then there is a sharp transition from knowledge transfer to independent problem solving by students. Some students are not ready for this and such students are excluded from the lesson. It is worth paying attention to the presence of intermediate tasks with support before the students move on to independent problem solving.
2.4 Application and Integration
When students have learned to solve small isolated problems on the studied skill, it is necessary to gradually expand the context of the problems. Give more complex problems that require the use of not only the studied constructions, but also other previously covered constructions/concepts of programming. In the example with useEffect, you can ask students to write a program that will use previously covered useState, useRef, rendering an array in JSX, etc.
At the same time, one should not underestimate the difficulty of such tasks for students. The fact that they will use only previously learned structures often makes them perceive such tasks as simple for students, and sometimes even refuse them due to the greater priority of learning a new topic. However, the integration and joint use of several skills is a separate complex learning task. Students can individually apply the learned structures quite well, but at the same time be unable to write complex programs. Considering that the ultimate goal of learning programming is to solve business problems that require the joint use of a wide range of skills, integration is an important learning step that should not be skipped or left for the end of the course.
As for the difficulties for teachers at this stage, those who reach such integrated practice may not always have enough time for it, given the low speed of students' programming. A common misconception is that a large complex project at the end is enough for integration. This is not true, regular “continuous integration” is needed.
2.5 Assessment and Reflection
Assessment occurs throughout the lesson. The teacher should constantly correlate the course of his/her narration, proposed activities, tasks with how well students master new knowledge and skills. However, towards the end of the lesson or the end of studying the topic, it is necessary to pay more attention to assessment in order to form a sufficiently clear understanding of the students' capabilities:
What do students know/understand and what do they understand from what they have covered?
What can they write, what problems can they solve?
Can the acquired skills be integrated into the context of more complex tasks?
When assessing, you must first rely on observations:
You asked something and the students gave you reasoned answers;
They gave students problems or more complex projects and the students solved them themselves.
There is a great temptation to go down the path of: “Well, I told them this”, “Well, we analyzed such an example”, so they should know, be able to, etc. That is, to evaluate students based on what you, as a teacher, said, showed, wrote, and not what the students themselves did. At the evaluation stage, it is not about what students should do, but what they can actually do. This seems obvious, but misconceptions occur here in 3 out of 4 cases.
In general, assessing students' knowledge during a lesson is one of the most difficult and non-obvious tasks for a teacher. On the one hand, you can't get into everyone's head. On the other hand, a weak understanding of students' capabilities is associated with a lecture-based teaching style. In this case, there are simply not enough activities during the lesson where students can show themselves, and the teacher, based on observations of their work, can form an idea of the students' level.
Incorrect assessment or lack of assessment in general gradually leads to an ever-widening gap between the teacher and the students. Students understand the lessons less and less and participate less, it is increasingly difficult for them to formulate any specific questions, most of them become withdrawn, and a smaller number become more aggressive. Correction of such a situation again begins with the assessment of students in order to form a clear picture of the real state of affairs in the teacher: the real knowledge and capabilities of the students, from which it is necessary to start when conducting lessons.
Reflection here is understood as a student's self-assessment or a student's idea of his/her knowledge, skills, and capabilities. This is a separate soft skill that most students have rather poorly developed.
During the lessons, it is advisable to encourage students to reflect on what they have understood, what they can write, what problems they can solve. Ask simple questions, for example,
What do you feel confident in and what do you not feel confident in in this new topic?
What do you find illogical or confusing about the new topic?
Imagine what problems you could solve with your current understanding of the topic? Think about when difficulties might arise.
There is no need for complex questions here. Regular work with reflection will help you 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 is to demonstrate misunderstanding, etc.
2.6 Reinforcement
Formation of even a simple skill is rarely limited to one lesson. Especially if we are talking about a stable skill that will stay with the student for a long time, and which the student will be able to consciously apply in various contexts. Unfortunately, our processes of forming neuronal connections are not so fast and straightforward. Therefore, repeated regular practice is important, during which the student accumulates both a large amount of practice in performing the target algorithm of actions, and many different contexts of applying the skill.
Repeated, regular practice does not mean that you need to solve problems on all the topics covered every lesson. This is excessive and will not work in terms of time. On the contrary, over time, the intervals between repetitions should be increased.
Consolidation will occur naturally if, when studying new topics, the teacher regularly goes through the Application and Integration of Skill stage with students, which involves solving complex problems that include not only the new structure being studied, but also previously studied topics. And here it is worth watching yourself so as not to give any similar tasks, where, for example, work with an array and a for loop is constantly used, but objects and a while loop are used too rarely. When coming up with an integration task, you should simply ask yourself, what of what we have studied so far have we not used for a long time?
2.7 Working with the stages of skill formation
The learning process is not linear. You can return to certain stages many times during the process. Some stages run parallel to others (for example, learning, assessment, and reflection). It is not always necessary to go through all the stages. However, having an understanding of the process of skill formation in your head is useful. By analyzing the lessons and these stages, you can better understand the problems students have with developing programming skills.
