This page provides insights into some of the innovations that I have experimented with in my classes.  Many of these methods and techniques are based on approaches described in education literature, observations of and feedback from colleagues and information gathered from workshops and conferences.  Some of these innovations I have employed and evolved in my classrooms over the years with anecdotal success while others that have begun as experimentation are developing into larger research projects to evaluate their educational impact.

Leveraging Technology

• course management systems (conneX, EdX, Connect, Sakai, CourseSpaces, BrightSpace(D2L))
  • These support a centralized repository for communication with students and are used across most institutions.
• grading scripts
  • developed to facilitate qualitative and quantitative assessment of code submissions
  • integration with existing testing frameworks
  • integration with import/export features of learning management systems
• online discussion forums (through course management systems, Piazza)
  • I see the benefit of forums in facilitating discussion for those not able to interact with other students and the teaching team directly.  I direct students towards resources and answer with questions rather than providing a direct answer.  When working with an undergraduate TA team I mentor them through the same approach.  I do this for two reasons:
    • to encourage students to reason about the question itself to develop their learning skills
    • to allow other students to contribute to the discussion and establish an inclusive learning environment
• polling software (iClicker, REEF Polling, Socrative, Zoom polling) to ask multiple choice questions during lecture.  I have used polling software to facilitate the following:
  • at the beginning of class to encourage attendance
  • throughout the class on new material to elicit feedback on concept comprehension
  • in lectures on preparation and review strategies to encourage reflection and development of productive study strategies
  • after midterms and problems sets to elicit feedback on student self-efficacy
• exam-scanning system providing support for
  • using online grading systems (GradeScope)
  • quick handback and facilitating regrade requests
• screen-cast videos…
  • to provide pre-lecture preparation in short segments
  • to augment lecture, allowing students to review material covered at their own pace
  • to provide explanations for misconceptions identified broadly on exams and problem sets
• programming practice tool
  • a supplementary resource for students to practice skills and constructs covered in lecture and lab
  • shared across sections and terms for use by other instructors
• anonymous feedback (sayatme.com)
  • provides students an avenue to provide feedback on the course while the course is running

Going Unplugged

• Visualizations – You can see examples of some of the visualizations that I have created for CPSC 110 on my Curriculum Development page. The development of visualizations for compounding material in a course is influenced by research that shows the human brain has better recognition memory for pictures over words. I have shared these visualizations across sections for use by other instructors on request.  Anecdotally, I find establishing a visual representation of a concept that will be built-on throughout the term provides:
  • a link to students’ previously developed knowledge
  • a visual representation of how new concepts build on existing concepts
  • a starting point for discussion of similarities and differences between constructs
• Kinesthetic learning – I often like to take the term “active-learning” literally and get students to interact with a physical representation of the construct.  This approach is largely influenced by research on human-learning cognitive psychology which states “As humans we do not store verbatim copies of experiences in our memory. Rather, we integrate new incoming information from the surroundings in relation to our pre-existing knowledge about the world.”  Often students come into first year computer science without any programming background.  I look for examples students are familiar with to explain new constructs that I am teaching them.  For example:
  • providing students with numbered playing cards to experiment with or develop sorting algorithms
  • using a deck of cards to establish a conceptual model of recursive functions
    – taking the top card off (first) and reasoning about how to combine it with the result of the recursion on the remaining stack of cards (rest)
    – demonstrating that the initial combination to occur is that of the first and the base-case result.  ie. trace the mechanics of the recursive calls going through the set of cards to the bottom (base-case) and combining results from the bottom (base-case result) back up to the top (first).
  • using the analogy of rooms in a house (common area, your room, your sister’s room) to explain global versus local scope
  • having students act as functions to comprehend the difference between pass-by-value vs pass-by-reference:
    • one student communicates a value they have written on their paper to a second student who then writes the value down and makes a change to their copy of the value, each student has two different values
    • one student tells the location of a value to the other student who then makes a change to the value at that location, both students are pointing to the same value
  • having students act as functions to explain function pointers
    • one student acts as a function which takes a list (set of cards) as an argument and that function does some operation on each card
    • one student acts as an abstract function that takes a list (set of cards) as an argument AND another function which is a second student
    • students physically encounter constraints of abstract functions (ie. the abstract function student can only pass one card at a time to the second student)
  • using a physical foam ball to represent an exception
    • I act as the calling function, the student is the called function
    • have the student throw the “exception” when thrown and demonstrate
      • if it is not caught, the VM is left to handle it and program crashes
      • the calling function can catch the exception and handle it
    • Expanding the number of participants, extend the call chain and demonstrate how the exception can be caught and continue to be thrown up the call chain
  • connecting students in their seats as a linked list of nodes
    • use coloured paper to write the name of the ‘next’ person in the list
    • students see the non-contiguous characteristic of the data and dynamic allocation of memory