Table of Contents

1. Introduction
2. Motivation
3. SWS3012 and being Avenger Mentor
4. The Avenger work in the semester
   1. 1. Value-adding
      1. 1.1 Material Preparation
      2. 1.2. Interaction in tutorials and consultations
   2. 2. Teaching recursion early
   3. 3. Reinforcing my own understanding of the material
5. Conclusion

Introduction

In NUS, CS1101S Programming Methodology is the introductory course to programming for CS freshmen. It uses the Structure and Interpretation of Computer Programs textbook, which is adapted to JavaScript (it was recently announced that the adaptation is going public!). The course itself is actually taught by using a subset of JavaScript called Source, written and developed by the teaching team together with some students. I am aware that there are many undesirable things in JS, and Source aims to mitigate that by “providing the good parts”. That way, freshmen can still learn fundamentals of programming without having to learn the intricacies of the actual JS.

The module has been taught by Assoc Prof Martin Henz and Dr Low Kok Lim for several years now. Traditionally, it used to be an optional 5-Modular Credits module, slightly more workload compared to a standard 4-MC module. As of AY18/19 (the year I matriculated), it became a compulsory 4-MC module for CS freshmen.

Avenger is a term used in the module to refer to the tutors, usually undergraduates. A tutorial¹ class in CS1101S usually comprises of 6 to 8 students (only!), and led by an Avenger which serves the role of facilitating discussions. Perhaps they are best described as ‘Discussion Group Facilitators’. But hey, that’s a mouthful, and an ‘Avenger’ does sound way cooler!

In AY19/20 Sem 1 (Fall 2019), I took up the role of an Avenger. I led a discussion group of 6 students (initially it was supposed to be 8 but there was some reshuffling around). It’s been a super busy semester, and I would like to share my experience on being one. If you are a student contemplating on whether to apply on being an Avenger, hope this post can help provide you with some insights!

Actually, during the holiday break prior to the sem, I also worked as an Avenger for SWS3012, which is a 2-week Summer Workshop for visiting international students, taught with condensed CS1101S material. Due to this exposure, Prof Martin asked if I was willing to be an “Avenger Mentor” to mentor the new Avengers once the sem took a full swing. I took up this role. I will briefly talk about these 2 experiences as well.

This post will not be a review of the module, but rather a reflection on my experience as an Avenger, as well as my personal approach to being one.

Motivation

Let’s start by talking about why I decided to take up the role.

I actually came into CS with barely any background. As I was taking the module, I was rather so-so at first. I could grasp the basics of recursion (which is pretty central to the module), but could not solve the advanced problems easily. It was only closer to midterms when I was attending Eldric’s (a graduate teaching assistant) remedial session on trees that I felt everything suddenly clicked. I realised how powerful the concept of “Wishful Thinking” was, and I would say that my skills improved quite significantly since.

The module is by no means easy, and throughout the module I would discuss numerous things with friends. I would get questions, and explain them as best as I can. Over time, several of my friends reaffirmed my ability in teaching and started saying that I should be an Avenger. I laughed off the idea at first because I didn’t think I was ready to take such an important role, but all the support I received really really started encouraging me. My own Avenger Hieu also recommended me, which truly gave me the push I needed. Closer to the end of the semester, I was determined to be an Avenger.

I do really enjoy teaching and sharing my knowledge with others. It brings me so much joy whenever I managed to bring someone closer to understanding. I suppose it’s also a personal satisfaction knowing that I know the material well enough to explain it to others. It’s just that I was unsure whether I have what it takes to take up this role. So, all the encouragements I received played a huge part in my decision. Thank you everyone, for encouraging me!

Fast forward to the next semester, I applied and prepared hard for the interview. Truthfully, it felt like it was such a long time since I wanted something really badly. I practised teaching using a whiteboard so hard, that I actually strained my arm a few days before my interview! I found it painful to lift up my arms. I was pretty worried, but fortunately the interview went well. I was fully ready to support my right arm with my non-dominant left hand throughout the interview, but somehow my arm didn’t give up on me and could support itself.

Spoiler alert, I was offered the role! I was really thrilled, and looked forward to the experience!

SWS3012 and being Avenger Mentor

Proceeding chronologically, what happened next was SWS3012. I happened to be relatively free during the summer period (or so I thought, but that’s another story), and I thought that before going full swing into teaching in the semester, why not give myself an exposure?

Honestly, it was quite challenging in terms of communication. The visiting students had a decent command of the English language. However, programming can get very technical, and I always had doubts whether what I wanted to convey went through. I think the experience reminded me to be patient when I teach.

There was also a student who was lagging in the summer workshop module, and he struggled in understanding his assignments. I tried helping him go through his work, but it didn’t seem to work well. Another Avenger also helped me out, but his approach was different: instead of going through the assignment, he went through very simple examples from scratch. It’s such a simple approach, but I overlooked it. I was too focused on helping him finish his work, that I didn’t think of going through the entire concept from scratch. I was reminded that I should seek for long-term rather than short-term goals when presented the opportunity.

It was short, but nevertheless a fruitful experience. Although the summer and actual module styles are different, I felt slightly more prepared to teach properly in the semester.

Here is a class photo we took at their farewell dinner:

As mentioned before, I was also offered to be an Avenger Mentor, which is supposed to coach other “new” Avengers. I accepted the role, but I always felt it was weird for me to be in the position. I took the module together as classmates with the Avengers I am leading, so to say that I am “mentoring” them is a little strange.

That being said, I took the role of “leading” seriously. I ensured that I would answer the questions whenever I am capable, took initiative in things like writing meeting minutes, facilitated the discussion between fellow Avengers in my cluster, etc.

Thinking more deeply about this, I think what I went through is reflective of the working world: a team of Software Engineers may consist of members who are more knowledgeable than the one leading them, and that’s all right. What would matter was whether the leader could bring the best out of the members to achieve the same goal.

I am grateful to have been given this opportunity to lead. There was no form of official feedback given to Avenger Mentors, but I know I had tried my best and I can only hope that the Avengers in my cluster had a pleasant experience working with me and others.

The Avenger work in the semester

This should be the bulk of the reflection, yet I wrote so much already! Thank you for reading up to this point.

After everything that I have gone through, I generally had some goals I wanted to achieve when being an Avenger:

1. Value-add my students’ understanding in the subject material
2. Ensure that my students grasp the concept of recursion early
3. Reinforce my understanding of the CS1101S material

1. Value-adding

I think this point should naturally be the goal of every Avenger. While I did not explicitly plan this out, I realise that I subconsiously took a two-pronged approach:

1. Material preparation
2. Interaction in tutorials and consultations

1.1 Material Preparation

Material preparation for me was mostly done in the form of slides. I provide my materials this semester here. For future students who stumbled upon this post, take note that material covered is ever-changing.

Back when I was a student, my recitation teaching assistant Jin (we have 2 forms of “tutorials”, but I shall not go to details), prepared very detailed and helpful slides. I was very much inspired by him to do the same for my students. I e-mailed him when I was teaching SWS3012, and he kindly provided a detailed guideline to how he prepared his slides. I can’t thank him enough for that! It became some sort of reference for me, and I did use some of his old slides (with permission) to teach.

I prepared my slides with some things in mind:

• I want the slides to be mostly self-sufficient. Meaning, the students can refer to it without me needing to explain what I meant.
• It should provide a deeper understanding of the module content
• It needs some memes peppered in for the lulz

I want my slides to be self-sufficient in order to protect my own time. I hope that my slides can answer some questions students may have, without needing to ask me directly. Of course, I don’t mind questions, but me being a student too means that I need some time for my own studies as well.

I also have urgency in mind. It works both ways; what if a student urgently needs some answers (30 mins before exams?), and I cannot answer readily? Or what if I can, but lack some proper material to do so? I do find that having prepared these slides beforehand made consultations easier because I already have personal materials that I need to cover something.

I try to share some tips and tricks to tackle certain things. For example, whether a Binary Tree is a Binary Search Tree can be easily verified if you were to “drop” all the nodes and check whether they are all in-order (i.e. perform an inorder traversal and check if the numbers appears sorted). Another thing I like to do is to provide visualisation through diagrams, because I feel that it will improve understanding.

Lastly, memes. Heavily inspired by my tutor Jin as well. But also because I want the slides to be more light-hearted. Studying can get very tiring, and the least I can do is to make the experience more pleasant. I either find memes online, or adapt CS1101S-related things to a specific meme format. Here are some examples I created (which most likely require you to be a student/Avenger to understand):

Usually I release my slides at the end of my class, and share them to CS1101S students outside my class as well. Sharing is caring~

I personally feel that I have done a pretty good job in curating the slides. In particular, I was really proud of my Meta-Circular Evaluator slides. MCE is known to be a very hard-to-grasp topic, and I spared no effort in ensuring I can explain it well in my slides. What really thrilled me was that at some point, it reached 10 viewers simultaneously:

While in a cohort-level that’s not a lot, but 10 people is more than the students I have! That was a personal satisfaction for me that people are actually using my slides.

If you look through my slides, I put a lot and a lot of effort in preparing it. I tend to prepare it on my long bus rides, or when I am unproductive in my own studies. For some slides like Environment Model and Meta-Circular Evaluator, I stayed up later than my usual sleep time to prepare them. Honestly, it started becoming an addiction! It also serves for me to ensure that I understand the material enough. In the end, it was pretty satisfying though as I think some students benefitted from it. I received this message from a student outside my class, which really really really made me happy:

One thing that I consciously tried to avoid was adding my answers to my slides. I want students to think for the solutions themselves, and I purposely omitted the answers to tutorial questions. However, what I eventually started doing was to add students’ answers. I think that having gone through the tutorial, students deserve to learn from the answers that their peers have come up with. I feel that students ought to have taken notes of discussions happening in class, and what I tried to do in my slides was to bring it up further since I can provide comments and remarks. I hope that my students did not become lazy in note-taking or stopped listening to their peers because of this, though. On hindsight, I should have asked how they felt about how I approached providing answers!

On top of all these, I try to provide some extra questions at the end of my slides. These questions either tend to be exam-like questions (I think the early tutorial questions did not reflect exam style, so I wanted to set expectations), or tricky questions to really test their understanding. Some of these are actually my original questions (if I recall properly), but a handful came from other sources such as questions I have seen online before, or an adaptation of questions from higher-level modules. I try to avoid asking questions from past year papers because I feel like I want them to experience those questions in a timed-practice setting, unless I feel the question is an important one.

By providing so much, I constantly wondered whether I am spoon-feeding them. It’s hard to thread a fine balance between helping just enough, and spoon-feeding. I argued with myself that CS1101S is an introductory module. Students new to programming are likely to require more help. Then I argued back that they should get used to being independent early. Eventually, I gave in to the former argument. I think there’s ample opportunity for them to be independent in their learning. I value that I am able to provide them with a good foundation instead. I do try to strike a balance when I can; I leave some thinking questions in my slides instead of providing everything.

If I were to teach another module, I am not sure how much effort I will be putting into my slides. What I know is that I will likely be preparing something supplementary for students to refer to. Perhaps, I will then revisit the earlier arguments about helping and being independent.

1.2. Interaction in tutorials and consultations

When I was a student, my Avenger conducted the tutorial in a way that we begin by refreshing some concepts, followed by discussion among students, then presentation of answer by students. I adopted this style for my own class. All of this is to be done within around 1 hour 35 minutes, because tutorial slots are 2 hours long and we have to give students time to move to their next class.

With the help of my slides, I would be doing some form of revision with my students. This usually should not take more than 30 minutes, unless the topic is really packed. Then, I will let them break into pairs for discussions, giving them around another 30 minutes or so. I would walk around to follow their discussions, and answer questions which they may have. Finally, I would give them the opportunity to present their answers.

Revision is done simply because I think students don’t always come to class fully understanding what was gone through in lecture. I think the least I could do to ensure that they are not fully lost in class is to refresh their memories. Granted, the 2-hour long session made this possible. If it was a shorter slot, I may have to cut this out of the lesson plan.

I think breaking them into pairs and letting them actually discuss would make their learning more meaningful. When it was done to me, I felt my mind constantly engaged with my discussion partner. It’s either through learning something from the other party, or from reinforcing what I understand by explaining it. I did this to also allow students to have time to actually attempt the question if they haven’t already done so. Reflecting on my facilitation here, I think I could have done a better job going around. I realise I tend to just stand and wait, instead of actively listening in to their conversations. Although, I suppose I did not want to pressure them by being too nearby.

Lastly, I am quite insistent on letting the students present their answers. After having gone through one full round of being an Avenger, I truly believe that the best way to improve your understanding is by teaching others. I always assign a pair to question(s) for them to present. After their presentation, I open the floor for comments, and try to value-add the answers with my own thoughts. I am quite happy to say that the students I have are participative. There was only one studio session when I did all the answer explanations, and it was on MCE which can get very confusing. I am okay with helping out with that.

This is actually something that struck me pretty deeply during the Avenger interviews. Prof Martin shared that when Avengers pass the marker to their students to present, the students are being empowered. I couldn’t agree more with him; I feel that I am letting my students take charge of their learning. Avengers should strive to distance themselves away from the class. The focus of the class should not be on Avenger teaching, but rather on learning fueled by discussions.

Looking back, I didn’t have any complaints on how the class was conducted (maybe I got complaints in the teaching feedback but at the time of writing I haven’t received the feedback yet haha). I’d like to think that this style works. Although again, I believe that this heavily relies on the kinds of students I have in class. I have some strong students, and I can always rely on them to have a go at explaining the harder questions. In the future, if I were to conduct a similar style of class, I should be prepared for this not to work and to adapt accordingly.

As for consultations, what I try to do is to guide them towards the answers that they seek, instead of answering it directly. I ask a lot of “why”s, and a lot of “if you view the question like this, can you proceed?”. Admittedly, it gets a bit time-consuming because there is a lot of pauses. But their learning is what matters the most, so I hope it was beneficial. I think my record-long consultation was around 3-4 hours for a one-to-one consultation and I had this with several different students. Not sure how long is long, but I know tutors in other modules have gone through longer sessions than that. I admit it’s pretty tiring, but time really flies when you’re enjoying yourself.

Through all of these, I do hope that I have done much to value-add their learning.

2. Teaching recursion early

Recursion is arguably the most important tool at a CS1101S student’s disposal. A good majority of the questions can be solved with proper understanding of recursion, especially for midterms. I knew this through my experience as a CS1101S student. While this is seemingly a superficial goal, but I made it a point that my students should grasp this concept early.

On week 3, right after I met them for the first time, I offered to give a supplementary class on recursion. I wanted to make recursion very explicit for them. If you see the Google Drive for my slides, I had a slide where I attempted to give an enrichment on recursion. This was actually the first set of slides I prepared before school even started, because I knew I wanted to do this.

The majority of the class agreed to this session, but finding a common time was difficult. In the end, I split it into 2 sessions, and each session was around 2-3 hours along. I thought I was pretty crazy when I started giving “consultations” even in week 3 of school, but I think this reaped its benefits closer to midterms. Some of them became quite natural with wishful thinking and recursion. Whether it was through my explanations or not, I don’t know. But at the very least, these “consultations” allowed me to get to know my students better, both as a person and in their abilities early in the module.

3. Reinforcing my own understanding of the material

As I have previously mentioned, I believe that teaching is the best way for someone to reinforce their understanding. It may or may not be the best way to start learning, but teaching definitely has its benefits. I was really really fascinated by wishful thinking and recursion. I couldn’t stop thinking about it even after my first semester ended. So when I applied to be an Avenger, learning more was definitely one of my goals.

For example, I started having more appreciation to how one can recursively generate permutations and subsets in functional programming. The cool thing that happened was the same week I had to teach permutations, I had to answer an online coding challenge on permutations for an internship application process. The expected solution was an in-place solution (with O(n) stack space I think?) by displaying every permutation, while the CS1101S style takes at least n! space. And although I couldn’t fully come up with the solution that they expect, I think through my experience in my CS1101S, I could grasp recursive solutions and dynamic programming problems better, which made interview preparations more pleasant.

I definitely understood Meta-Circular Evaluator better now that I had to teach it as compared to when I was a student. I honestly feared teaching it, some Avengers and I joked that the tutorial for MCE was going to be the tutorial that our ratings were to drop. But in the end, I think it didn’t go too badly. I was pretty surprised at myself for being able to answer consultation questions on the topic too.

Another cool thing I learnt along the way was the Continuation-passing style. Maybe I can’t fully teach it from scratch now, but I definitely started having a better appreciation of the concept. It’s definitely interesting to “continue” the function by passing it in the body of a newly-defined function. The gist of the concept is to turn a recursive function which gives rise to recursive processes (which is defined as the accumulation of deferred operations), to one that gives rise to an iterative process (tail recursive). I take the following example from the lecture slides:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

// This is written in Source language

// Normal factorial
function factorial(n) {
  return n === 1 
         ? 1 
         : n * factorial(n - 1);
}

// CPS factorial
function cps_equal(x, y, cont) {
  return cont(x === y);
}

function cps_times(x, y, cont) {
  return cont(x * y);
}

function cps_minus(x, y, cont) {
  return cont(x - y);
}

function cps_factorial(n, cont) {
  return cps_equal(n, 1,
    b => b
         ? cont(1)
         : cps_minus(n, 1,
             x => cps_factorial(x, 
               f => cps_times(n, f, cont))));
}

cps_factorial(5, x => x);

I leave it as an exercise to the reader to figure out what is going on :P

When I was making an attempt on my own writing the above code, I did this:

1
2
3
4
5
6

function cps_factorial_fail(n, cont) {
  return n === 1 
         ? cont(1) 
         : cps_factorial_fail(n - 1, x => x * cont(n));
}
cps_factorial_fail(5, x => x);

The above example fails to be tail recursive, which I suppose is a purpose of CPS.

I also heard an argument that goes along the lines of CPS being a “cheat” to be tail recursive, because it actually trades stack space for heap space, which isn’t all that bad because we are likely to have more heap space anyway. Looks like I still have got some learning to do!

Before the semester started, I was pretty interested in Lambda Calculus as well. Imagine having a programming language where you can only declare and apply functions. But somehow, you can represent a lot of things with it starting from numerals, data structures, booleans, and even recursion. The higher-order programming feature of CS1101S meant that we touch a little bit on it, and there was even an optional homework assignment on this. Gave me quite a headache answering students’ questions on it, but I felt like I learnt a thing or two!

Lastly, I think the nicest thing about being an Avenger is being able to learn from your students as well. I learnt how people could approach a problem differently (and sometimes more elegantly), and not only that, I learnt from their positive attitudes as well.

I picked up this technique from one of my students, which I eventually used for an assignment in my algorithm class:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

// This is written in Source language

/* Suppose we want to check that the center element is strictly greater than all 
its neighbours in the 8 directions */
const target = [[1, 2, 3],
                [4, 5, 4],
                [3, 2, 1]];
// We can define two arrays to represent coordinate "offsets"
const dx = [-1, 0, 1, 1, 1, 0, -1, -1];
const dy = [-1, -1, -1, 0, 1, 1, 1, 0];

/* Notice that the dx[0] and dy[0] combined will represent neighbour in the
north-west. dx[1] and dy[1] combined will represent north neighbour ans so on */

// We can thus define the check as follows
function check(target) {
  let is_center_a_peak = true;
  for (let i = 0; i < 8; i = i + 1) {
    if (target[1 + dy[i]][1 + dx[i]] > target[1][1]) {
      is_center_a_peak = false;
      break;
    } else {}
  }
  return is_center_a_peak;
}

What I have above is a bit of a toy problem, but this can be generalised to many other cases. The nice thing about this method is its flexibility in defining the directions. For example, programming a Knight piece in chess. It may be slightly error prone in terms of whether you should access dy or dx first, but that aside I was pretty impressed by this technique.

Through this experience, I do realise that undergraduate teaching assistants shouldn’t be expected to know answers to everything. Every now and then it should be okay to learn something new from your students too (especially if they actually know more!). I certainly hope that students can understand where I come from. Afterall, I was a student just like them one year prior.

Conclusion

Phew! It is a super long post! Thank you very much if you have read this far. It’s been a truly busy semester. I think I have done so much work (and perhaps more than necessary), but I enjoyed every part of it!

Although towards the end my other modules actually suffered a bit, but I would like to think that it’s a relatively low price to pay if I could help the CS1101S students. (Actually, we’ll see if this thought still stands after my own results release this semester hahaha)

Many people have asked me whether it is time-consuming to teach. My answer to this is that going through the bare-minimum of teaching the tutorial, attending staff meetings, etc, shouldn’t actually take a lot of time. What I personally feel takes a lot of time is all the grading and consultations. Not to mention, all the short questions I received over chat actually amounted to quite a bit of time. Also for me personally, material preparation is one of the most time-consuming part of what I did in the semester. Perhaps I could have gone through the semester better if I hadn’t spent so much time on the materials, but that deviates from my goal of providing a good self-sufficient set of materials.

Going forward, I definitely can work on my time and priority management. Teaching is my responsibility, but perhaps it would be good for my own sake to learn to say “no” too. Maybe I’m sacrificing too much of my own well-being for others, which isn’t necessarily bad but I should be more mindful about it.

In the end, the Avengers received this Avenger pin which looks pretty cool in my opinion:

Before wrapping up this post, I would like to thank my students for making this journey really enjoyable! It’s been really really fun!

Would I be teaching CS1101S again in the future? Maybe. I’d love to. Actually, I indicated my interest to teach next semester, but it’s contingent on whether I get something else that is still pending. So, we’ll see!

And to wrap up, I’m going to use the phrase used to conclude CS1101S first lecture: May the Source be with you!