TA Training Exercise

Yesterday, we tried something new – a training session for the 15-122 TAs. While not exactly a novel concept, I think it was a really useful exercise and one that we should continue.

We began the session with an experienced TA teaching a concept for 5 to 10 minutes, followed by a group discussion on various aspects demonstrated in his teaching. He then did another 5-minute presentation which was full to the brim with examples of arguably “bad” teaching, such as reading off of dense PowerPoint slides, refusing to work through an example for a complicated concept, not listening to student feedback, casually dismissing errors on slides, and digressing into rambling about a vaguely-related topic. While these examples were useful, and somewhat amusing, teaching is best learned by doing it. So we did a hands-on exercise, where each TA taught a topic for 5 to 7 minutes, while the rest of us pretended to be students, peppering the presentation with questions that 15-122 students might have on the material. After each demonstration, we gave the TA feedback, highlighting the good points as well as areas to improve upon.

Everyone has a different style of teaching, and while I already knew this, yesterday’s exercise really highlighted the contrasts, with multiple people presenting their unique take on similar material. Some great teaching practices (from different people) included the creative use of analogies, projecting a contagious enthusiasm for the subject, clean detailed diagrams, and large clear handwriting on the blackboard. Of course there were some flaws as well, the most common ones being sub-optimal order of presentation of content (jumping around or missing out on critical content), allowing questions to distract from the main idea, and speaking too fast or too softly – things that are best learnt by experience. I feel that the feedback benefitted everyone, and that everyone did a great job overall!


Transferring files between your local computer and Andrew Unix

A bunch of people asked about this on Piazza, so I felt obliged to go ahead and write about it!

Mac and Linux users

I recommend using scp, a linux command for remote file copy using SSH. If you’re familiar with Unix, you’ll realize that the format for this command is very similar to the cp Unix command as

scp source destination

For example, let’s say Nobody (nobody@andrew.cmu.edu) wants to transfer the file foo.c0 from the Downloads folder on her local computer to her 15122 folder on Andrew Unix. (Our target andrewid is nobody, you should replace it with your own)

scp ~/Downloads/foo.c0 nobody@unix.andrew.cmu.edu:~/private/15122/

Conversely, if Nobody has finished editing her code and wants to copy it to the code folder on her local computer (maybe in order to upload to Autolab), she can use the scp command again with the source and destination switched, as follows.

scp nobody@unix.andrew.cmu.edu:~/private/15122/foo.c0 ~/code

You can refer to the man page for scp for more details and options. One very useful option is the -r flag which is used to copy over folders as opposed to files.

If you’re on a Mac, you can also use Fetch, if you would rather not work on the command line to transfer files.

Windows users

Not being a Windows user myself (I switched to Mac when I got to college), I recommend you take this advice with a grain of salt, as most of it is hearsay.

WinSCP, I’ve heard, is a very good option. I think it works a lot like Fetch for Mac users. There is ample documentation on the website that should probably get you up to speed on setting it up and using it. It also has good integration with the PuTTY SSH Client, that you’re probably using to SSH into Andrew Unix.

The Beginning…

Hey there! I’m Nivedita and I’m a junior at Carnegie Mellon, where I’m majoring in Computer Science (with a minor in Economics).

This is my 4th time as a Teaching Assistant for 15-122 : Principles of Imperative Computation, currently the first course in the core CS curriculum at CMU. The first part of the course is taught in C0 (pronounced c-nought), a language developed at CMU that is described by it’s creators as “a small safe subset of the C programming language, augmented with contracts.” As the semester rolls on, we introduce various data structures and algorithms, whilst setting the stage for a transition into C. Upon transitioning into C, we discuss memory management, generic data types, function pointers and various quirks of C. The course culminates with the students writing a virtual machine for C0 in C, that is able to execute byte code generated by the C0 compiler.

Most people blog about an experience that they’re having for the first time. Why am I doing it my fourth time? Because, along the bumpy road, I’ve learnt a lot and I think the time is ripe to share it, while I’m reliving the experience again. Some of it will be about the material, some of it will be about how I’m teaching it.

Looking back, I realize that I’ve learnt the most from the students taking the class. This semester promises to be no different, hence I’m dedicating this blog to the students taking 122 in Spring 2014. So hang on tight for a roller-coaster ride through a land of smiles and tears, hugs and frowns, where the C0 compiler and Autolab can make or break your day.

(For more info on C0, check http://c0.typesafety.net/)