Teaching can be a pretty much hit and miss affair. When a teacher is dealing with a class of thirty or so individuals, even the most carefully thought out lessons may miss the mark with many of the students. Very often teachers can see where a lesson is falling short by reading the room. They can see where a student has become disengaged, is staring out the window, or is covertly trying to go on their phone under the desk. Puzzled faces may indicate that a concept has not yet been grasped, or a sea of hands may indicate the majority of the class has got it! Teaching under lockdown, with muted mics and video switched off to avoid using too much data, has certainly been a challenge. It has thrown into sharp relief the problem of trying to track every individual’s progress. Gauging the effectiveness of teaching from assessing students’ written work may take too long, and question and answer feedback may give a general sense, but may leave occluded some very real shortfalls.
Computing is frequently viewed as a very difficult subject to teach. Students find it abstract and hard (Guzdial, 2020). How to make it more concrete, or simple for students to learn is therefore especially important. Difficult, abstract concepts need to be grounded in students’ own experiences to be effectively understood, but students also need to learn how to take their everyday understandings and re-pack them into the kinds of academic knowledge that we require. Karl Maton (2014) has given us tools for analysing and discussing this movement in his notion of Semantic Waves. Karl describes the dimension of semantics in terms of two polarities.
Firstly there is Semantic Gravity, which refers to how abstract or how concrete or contextualised something is. Abstract ideas can be generalised across different contexts. For example the term algorithm can be used in many different contexts both within and outside computer education. A particular algorithm, however, is heavily contextualized. You cannot use an algorithm for making a cup of tea when designing a program for a self-driving car, but both activities can be conceptualized as an algorithm. Teachers will frequently explain what an algorithm is by getting students to describe the steps used when making a cup of tea. This helps contextualize the concept, make it more concrete and accessible to students. But students will need to be able to generalize that understanding into other concepts, becoming more aware of what an algorithm is as they do so. Student understanding thus describes a wave from abstract to concrete and back again. Karl describes what is abstract as having weak semantic gravity (SG-), and what is heavily context-bound as having strong semantic gravity (SG+).
But beyond issues of how abstract or concrete something is, is the idea of how simple or complex something is. This describes the level of condensation – how much is packed into an idea. Karl describes this as Semantic Density. What is complex has strong semantic density (SD+), while simple concepts have weak semantic density (SD-). For example the idea of incrementing an amount by a certain amount is fairly simple. Every week a student gets a certain amount of pocket money. But the idea of incrementing by a variable amount that follows an algorithmic progression is more complex, there is greater semantic density. The idea of incrementation is made more complex, and more dense, by including the idea of progressive increase.
There has been an increased awareness of the usefulness of semantic waves in computer education (Waite et al, 2019). The image below shows how the concept of an algorithm has been unpacked and repacked by the teacher and students using a magic trick (Curzon et al, 2020). The semantic wave here describes a movement between abstract, harder to understand concepts, and concrete, easier to understand ideas, ie. semantic gravity. By consciously linking the magic trick to the steps necessary for the trick to work every time, students’ understanding of algorithms is developed.
Semantic waves are crucial in understanding how knowledge is unpacked and repacked. But waves are useful in describing contexts in which the abstraction/context dependence of something – semantic gravity – moves in unison with the complexity or condensation of ideas – semantic density. The two frequently track together, but not always. Sometimes there might be an increase in the level of complexity, but not of abstraction, or in abstraction, but not complexity. In this case it is useful to track these movements separately.
The idea of Semantic Tours helps us to understand those occasions when the movement over time of semantic gravity and density diverge. A tour represents movement from one place to another, and in different directions. Tours can take different routes and be in one direction or describe a return trip.
This past year I have been teaching coding to grade 8 students using block code for the BBC micro:bit chip on an online interface. Because of the pandemic, I had to use a flexible synchronous/asynchronous flipped learning style solution. The nature of remote learning made it particularly difficult to follow students as they created algorithms or coded their applications. Normally I can lean over a computer screen and see what a student is doing. I can get students to create their algorithms on the board or in groups and can intervene or invite comment from other students on the steps being taken. But in an online environment there is far less visibility and far less interactivity possible. Students shared screenshots with me and I was able to discuss approaches and ideas one on one, but each interaction was so time consuming that the level of engagement overall was limited.
In this context I found that it was relatively more important for me to be able to quickly identify where students were with their progress, so as to be able to make useful feedback. Semantic Tours to the rescue!
Let us look at some examples of student code. In all the examples, students were programming a robot to move in a square. All the examples were using block code for a BBC micro:bit chip. The students were high school grade 8s taking an introductory coding & robotics module. Some had experience of coding or robotics classes in junior school or as extra-murals, others had no experience of coding at all. Maton (2014) describes four distinct codes based on the relative strength of abstraction/contextual-dependence (semantic gravity) and condensation/complexity (semantic density). In the figure below (Maton, 2014) we can see the semantic plane which describes four “codes”.
The Prosaic Code (SG+, SD-)
Concrete & Simple
In this example the student has selected blocks which would get the robot to move in a square (depending upon the speeds being accurate). The code is heavily contextualised (SG+) and relatively simple (SD-). There is no condensation of ideas and no abstraction out of the particular context. In many ways it reflects the most simple and direct approach to solving the problem (SG+, SD-).
While the task reflects a correct response to the challenge, it does not evidence much growth in the student’s grasp of programming concepts.
It is important to note that there is nothing wrong with the prosaic code. Sometimes one needs to be simple and direct – often that represents the best solution. But as a teacher one wants to give one’s students the tools to be able to approach a problem on multiple levels and find the best solution.
The Rarefied Code (SG-, SD-)
Abstract & Simple
In the next example we can see that a student has used a function call. The code itself is simple (SD-), a series of forward movements and turns to create a square, but by being used inside a function, the code can be called up across multiple contexts (SG-). The function therefore represents a weakening of semantic gravity. The function call also represents a strengthening of semantic density when that call is used, but principally remains at a simple level despite the increased level of abstraction (SG-,SD-).
Other examples of strengthened abstraction would include global variables used across a program, or conditional statements which are defined in one part of the program and actioned when and if logical conditions are met.
The Worldly Code (SG+, SD+)
Concrete & Complex
In the next example, the student has used a repeat loop to condense meaning (SD+). Instead of writing out a forward motion and turn four times, the loop considerably shortens the code required – the condensation is quite visual. The code is still heavily contextualized though (SG+). Variables or function calls have not been used to allow the code to be used in different contexts. If another square is to be created the code would have to be re-written.
In order to reach this level of condensation, students appear to need to think through what is involved in drawing a square. Before realising that forward movement and a turn can be repeated four times, it is necessary to understand what forward movements and turns are required.
Other examples of condensation would include the use of attributes, while and for loops and variables that store the results of calculations or formulae.
The Rhizomatic Code (SG-, SD+)
Abstract & Complex
Some students combined both greater levels of abstraction (SG-) and increased complexity (SD+), using what they had learned about function calls and repeat loops at the same time.
The Codes described here do not represent value judgements. There is nothing necessarily superior about one code or another. However, it is true that students do need to be able to move between one code and another according to what is appropriate within a given context. It would appear to be movement that describes progress in learning. This movement between codes is expressed in the idea of the Tour. In the task we have been discussing, the code in the final example represents the most elegant solution, although all are technically correct solutions. It shows the most understanding of programming skills which have been taught.
Equally though, it is clear that students need to move through different codes as their understanding and mastery develops. In the graphic below we can see that the plurality of students used both abstraction and complexity (48%). A quarter, however, tackled the task in the most simple and direct manner (25%). Fewer students added either complexity (15%) or abstraction (12%), but not both together. A slight majority of students, thus, did not use both increased abstraction and condensation at the same time.
The chart above shows how all the students in the class tackled one particular task and gave me as a teacher a snapshot of where each student was sitting relative to the rest of the class. Given that the aim of the progression of tasks was to move students towards greater condensation and abstraction by learning how to use functions, an understanding that my students were taking semantic tours allowed me to target individual feedback to help them explore greater condensation or abstraction. It also clearly showed that students tend to take different routes. Knowing this is a great help in quickly identifying where students are and how to help them along the way.
Looking at the course as a whole, which consisted of 18 tasks, it is also possible to identify the paths taken by individual students in greater detail and compare this to the instructional input given. This is a useful reflective and research tool. Quite impossible in the ebb and flow of a lesson, of course. But I found it very useful as a teacher/researcher.
By drawing up maps of the tours made by individual students it was clear that different students took different paths. In the chart below we can see that Student A spent most of their time in the prosaic code with relatively short tours into other codes, although 33% of the time was spent in the worldly code.
Student B, on the other hand spent more time in both the rarefied and rhizomatic codes, and moved into the worldly code sooner than student A.
This suggests that the paths students take while learning coding skills can be somewhat idiosyncratic, and that there is often a lag between a teacher making a move along a particular path, and individual students being ready or able to follow. The zone of proximal development acts as a very real constraint.
My gut feeling, and I have not been able to adequately reflect on what this analysis tells me, is that it suggests that teachers need to be able to chart broad paths describing particular semantic tours appropriate to the content being studied, but also need to be able to circle back and find ways of picking up the stragglers. Teachers also need to be aware that some students will take alternate routes, and need to be able to signpost and scaffold those who stray. I have adapted my online lessons so that I treat quite consciously with moves to strengthen or weaken abstraction and density within each lesson segment. I do this on the principle that students will probably pick up on what they need to hear, and ignore what might be too much for them at that moment.
Curzon, P., Waite, J., Maton, K., & Donohue, J. (2020). Using semantic waves to analyse the effectiveness of unplugged computing activities. ACM International Conference Proceeding Series, October. https://doi.org/10.1145/3421590.3421606
Guzdial, M. (2020). Defining CS Ed out of existence: Have we made CS too hard to learn and teach? Computing Education Research Blog. https://computinged.wordpress.com/2020/03/09/defining-ourselves-out-of-existence-have-we-made-cs-too-hard-to-learn-and-teach/
Maton, K. (2014) Knowledge and Knowers: Towards a realist sociology of education. Routledge.
Waite, J., Curzon, P., Maton, K., & Tuttiett, L. (2019). Unplugged Computing and Semantic Waves: Analysing Crazy Characters. United Kingdom and Ireland Computing Education Research. https://doi.org/10.1145/1122445.1122456