Thursday, April 30, 2015

Two Semesters Teaching CS2 With C++ and Java

As you may recall, I have been experimenting with a CS2 design that teaches both C++ and Java in a single semester.  I previously reported on the success of the design after teaching a section of majors and non-majors in the off-term.  This semester, we used an iteration of the design with two large sections taught by myself and another instructor.  Most students this semester took CS2 immediately after taking CS1 last semester.

The grades for my section are shown above (the other section's distribution was similar).  As you can see, students generally either "got it" or they didn't.  The average of all final exams in the two sections was about 70%, as was the average final grade (I expected worse for both measures).  No concessions were made to massage grades other than to drop marks for one of eleven assignments (dropping one tutorial mark of eleven and one quiz mark of three was always planned).

Aside from better preparing students for our second year courses, a major goal of the redesign was to ensure that students who do not master the concepts don't continue.  My hope is that the grade distribution above indicates this will happen.  Certainly my design has enabled me to assess deeper understanding of concepts that serve as a foundation to what comes next; such concepts were not prominent (or even existent) in previous designs.

Much of the course design was stable from last term, with some improvements in sequencing and in class code examples.  The topics now progress rather nicely from a low level procedural view of problem solving, all the way up to advanced object-oriented programming.  The new topic list follows.
  • Introduction
    • Introduction to problem solving
    • Introduction to C++
    • Pure puzzles
  • Solving Problems With Arrays (C++)
    • Arrays and structs  (including memory models)
    • Solving problems with arrays
  • Solving Problems With Dynamic Memory (C++)
    • Stack and heap
    • Pointers
    • Dynamic memory
  • Object-Oriented Basics
    • Introduction to objects (including memory models)
    • Introduction to Java
    • Object behaviour (constructors, methods)
    • References and linked lists in Java
    • Shallow vs deep copying in Java
  • Solving Problems With Classes (Java)
    • Goals of class use (encapsulation, information hiding, etc)
    • Complex reference structures
    • Separated presentation design
    • Abstract data types
  • Advanced Object-Oriented Programming (Java)
    • Class hierarchies and inheritance
    • Polymorphism
    • Abstract classes and interfaces
  • Event-Driven Programming (Java)
    • Introduction to Processing
    • Model-view-controller
    • Polymorphism you can see
  • Solving Problems With Recursion (Java)
My slides and code examples (other than code directly from our textbook, Think Like a Programmer) can be found on GitHub.

This summer, the course will be taught according to the current design, and so far it seems the plan is to continue with it next year to give time to evaluate how well students were prepared for second year.  It will be interesting to see whether it will be used long term, and if so, how it will evolve.

Tuesday, April 7, 2015

Spring Research Update

It's been a while since I last did a research update. With spring (sort of) arriving, there's no better time to reflect on a winter's worth of hard work.

First / Dean Gugler 

Coherent Emergent Stories

Most of my effort in the last 8 months has been dedicated to teaching, but despite this, I managed to make progress on my PhD and thesis project.  In the fall, I spent time putting together my thesis proposal, trying to make the content as close to final-thesis quality as I could.  Then I proposed in December.

Since then, I have been dabbling with a next-iteration prototype to test my story ideas.  Instead of trying to craft an entire game, I am focusing on what I call a "story explorer."  I am designing the prototype to be as data-driven as possible so I can quickly and easily test many different stories and approaches to arranging those stories with my story engine.

Gram's House

The Gram's House project is a labour of love, and I am so excited to see how far it has come since I came up with the idea years ago.

Lately we've been hard at work on the NSF AISL Pathways grant we were awarded to study the effect of story on teaching computer science concepts with games to middle school girls.  We have been working on prototypes for three analog games to be used in informal settings.  The game cover the concepts of data representation (specifically images), data organization (searching and sorting), and algorithms (writing and reading precise instructions).

It has been a lot of fun coming up with the game designs, but also very challenging.  I really want to make sure we have something more than a lightly gamified activity.  I want the games to have inherently interesting and motivating goals that happen to require understanding of our CS concepts to achieve.  I want the games to present interesting and meaningful choices to players, and have at least some degree of replayability.  I'm not sure that our current games have all these features, and I am convinced that we can come up with even better designs.  Hopefully our resident story and game design expert Lorraine Hopping will stay patient with my constant pushing, because she has been an amazing asset to this project and has a lot more experience than I do!

Something else exciting is that two of my first year students may be joining the procedural content generation grant team at Northeastern University in Boston this summer.  I am beyond thrilled to be able to enable this kind of opportunity, and I can't wait to see what they are able to accomplish.

In addition to the summary of Gram's House on my own webpage, we have started an official project site hosted by Northeastern.  We are still working on adding content, but that should be a good place to find information about the project in the future.

Monday, February 23, 2015

One Instructor's Flipped Classroom Philosophy

Earlier this month, our Education Development Centre hosted a teaching round table on the flipped classroom.  At the session, engineering instructor Shermeen Nizami shared her philosophy for flipping her own fourth year undergraduate class.

Nizami began by sharing Rogers' diffusion of innovation theory.  She found this after her first flipped course was over, but felt it correlated well with that happened in class.  As shown in the below diagram, there are innovators, early adopters, the early majority, the late majority, and the laggards.  The distribution of these groups is shown in blue, while market share of an innovation is shown in yellow.  A question Nizami asked herself was who is in the chasm? Why do some students feel like the flipped classroom teacher is not doing her job? ("I want you to lecture to me!") For any classroom innovation to be successful, we need buy-in from students.

Why flip in the first place? In any given class, 30% of learners are apparently blocked; they can't be reached.  60% might be described as passive learners, and only 10% as active learners.  Could flipping help bring more students into the active segment? Is it worth it? It is if you believe that more students fail a lecture-based class than an active class, and that the rates of retention claimed in the learning pyramid are even close to accurate.

How do you flip? Nizimi says teachers need to look through the eyes of a student, and help students see themselves as their own teachers.  The mindset of both the student and the teacher need to be flipped. The teacher needs to be careful to keep students at the points of maximal learning: at the edge of their comfort zone, but not quite into the panic zone.

Design thinking gave Nizimi an useful model with which to approach her classroom:
  • Empathize: validate the level of difficulty students face in class
  • Define: gain students' confidence that you are on their side and not trying to trick them
  • Ideate: involve students and come up with creative solutions
  • Prototype: create opportunities for students to try out the proposed solutions
  • Test: solicit student feedback; be brave
The round table ended before we got a chance to get into the meat of what Nizimi's students were actually asked to do before and during class, but I did appreciate the constant reminder that we should involve students in the learning process as much as possible.  Whether I get the opportunity to formally flip or not, I hope to keep that thought in mind in all my teaching practice.

Thursday, February 12, 2015

Review / Ruby Wizardry: An Introduction to Programming for Kids

I think story is a powerful way to teach computer science.  I also think that too many programming books are boring.  Boring is fine for the experienced programmer looking to learn a new language, but maybe not so great for a beginner  someone we have a chance to hook onto programming!

Enter Ruby Wizardry, a book from No Starch that teaches basic Ruby concepts through a fun adventure story.  This is the programming book I've been waiting for!

Ruby Wizardry opens with a scene featuring the King and two kids from his kingdom, Scarlet and Ruben.  The King has lost his string, and needs the kids to help him find it.  Computing devices are all over town, allowing those skilled in Ruby to affect their surroundings.  From the public transit that runs on while loops to menus at the local eatery, it seems that Ruby is everywhere.  After finding the King's string, Scarlet and Ruben travel around town with the King, slowly uncovering some kind of devious plot that will be up to them to stop.

There are many things to love about this book.  The story is charming, and puts female characters at the forefront as competent programmers.  For example, the King himself is a bit of a luddite that tries his best to learn some Ruby along the way.  Meanwhile, his wife, the Queen, is "quite the hacker."  The conceptual content is embedded nicely into the story, and concepts are explained in an informal, conversational style.  I mean this literally  the characters are often teaching each other about Ruby, also allowing common misconceptions or admissions of not understanding to come up.  Everything you learn in a chapter is reinforced multiple times, and each chapter includes a mini-project and detailed summary.

There are some issues from a pedagogical standpoint.  Perhaps this is because the author of this book, Eric Weinstein, seems to have been educated as an author first and a programmer second.  There are certainly times when even I get lost in the Ruby syntax (I'm new to Ruby).  I don't think it's necessary to show four different ways to accomplish the same thing, especially when one of those ways is a lot easier to understand than the others.  The goal of a book like this is not to teach all of Ruby, but to introduce readers to the basic concepts of programming and set them up for success should they wish to continue learning.  It seems that this is forgotten at times.

Nonetheless, I am thrilled with this book.  I sincerely hope that more programming books will soon appear that use story or other contexts to deeply embed concepts into.  I think it's a great way to introduce anyone to programming, whether young or just young at heart.

(If you act fast, you can get a copy of Ruby Wizardy in this awesome No Starch Humble Brainiac Book Bundle!)

Monday, January 19, 2015

A Comic About Grace Hopper

Ramya from Udemy shared a neat little comic with me about Grace Hopper, and said I could share it here.  You can look at the comic on their website, too, where you can also order a Grace Hopper sticker if you live in the US.  Enjoy!