
Learning programming at scale - danso
http://radar.oreilly.com/2015/08/learning-programming-at-scale.html
======
biot
I was anticipating this to be "Learning (Programming at Scale)" but it's
instead "(Learning Programming) at Scale". A slightly different challenge. :)

------
danso
I just had a revelation while reading the OP (who describes a much more
elaborate, fully-featured system)...yesterday I was teaching students (about
20) how to do calculations with Pivot Tables using Google Sheets and was
struggling with the usual "well-can-you-describe-exactly-what-syntax-error-
you-made" problems...and now realize that I could've just had students give me
read/edit access to their sheets and I could've just cycled to their tab and
corrected their problem for everyone to see on the projector.

I would love to have a code editing system that is as easy as that...I only
have to deal with 20-or-so students at a time, so I don't need anything
fancier than a way to manage 20-tabs at the same time. Having a way to jump to
and collaborate on a student's session in the same way I can Cmt-T through a
Sublime Text/Atom project would be all I needed.

~~~
grayclhn
It's maybe not perfect, but can you have them working in a shared dropbox
directory in class? (Or something equivalent.) Then just open or refresh the
file...

IPython notebooks running on a central server is potentially another option
for some languages.

edit: if you do find a working solution, please write it up and post it. I'd
love to hear what works.

~~~
danso
Ah...that's pretty smart, too. It wouldn't be as slick of a collaborative
environment, but at least I can grep the entire class folder in one go. I will
seriously consider this!

------
jackmaney
These things look neat, but wouldn't this be _teaching_ programming at scale?
The phrase "learning programming at scale" leads to the idea of someone trying
to learn how to program who is also able to repeatedly enlarge the amount of
stuff that s/he is able to learn at once. That's...not really what's going on
here.

~~~
ljk
Also, doesn't this only work with intro materials that only have a few lines?
How's this way of teaching programming going to work if the program is
hundreds of lines long, across multiple files, or have more than one correct
solution? The debugging time alone would go up very quickly

~~~
omouse
Right and that's why there's things like AirPair where the cost of tutoring
goes up and is paid per minute due to the complexity. This scaling has a limit
but it's the same as any other field; how many artists go on to be great
artists after all?

------
bobochan
This is very timely. For the past few years I have been teaching a programming
course to small groups of beginning students, generally no more than 15. The
goal is teach them the basics over the course of a semester, and we usually
get there. The only downside is that it takes me about 30 minutes to review
each assignment (there are two a week) and write feedback to the student. With
15 hours of grading a week, it seems hard to imagine teaching much bigger
sections.

I went to a small college, so my programming courses were typically about the
same size, 10-20 students. How do larger sections work in terms of getting
feedback from professors? It seems critical, especially early on, to be able
to understand the way students are trying to solve problems and then give them
guidance how to get there. That seems to require more than "yes/no your code
passed the unit test."

~~~
tsumnia
I teach Java and Python intro courses at two different colleges (both < 30 per
class), and the way I've developed my courses are very unit test driven. The
reason is when I hand graded, it would take easily hours to finish grading
everything. Likewise, students would submit code they copy/pasted from the
internet and wouldn't compile. After 5 minutes of debugging their code, it
begins eating into my overall grading time. Likewise, what percentage should I
give them on code that doesn't compile? Now, I say a flat "if it doesn't
compile, the best you get is 20% for proper formatting".

In the first few weeks, I use JUnit and System Rules (I am currently build
Python unit tests) to let them only work via the main method. Once we
introduce methods, I show them how I call them via my tests.

I have also started implementing typing exercises into my weekly work, so
students can get a feel before getting thrown to the wolves on the week's
assignments. If I head to PyCon next year, I hope to present on whether it was
successful or not.

I am looking to automate grading ala Open edX style submissions, as the
biggest problem I have is not being able to give students a grade/notes until
around Friday when I grade.

One trick I do is lecture all of Monday (2 hour class) and then let them work
on their assignment for the week on Wednesday (3 hours). Most students don't
realize how much time outside of class needs to be spent in the initial
semesters of programming. I use that lab time to let them work and act as a
helpful tool if they have questions. For example, this week, we'd gone over
building Objects, but the idea of constructors are still shaky to some people.
Today, when they were working on their labs, I spent some time with the 1-2
students that needed a little extra help understanding the work to get
everything.

~~~
bobochan
Thanks to everyone for their excellent suggestions.

One of my reservations about going to an automated testing and grading
approach is that the course evaluations consistently say that the personalized
feedback is an important reason that they took the course. But the fact is
that line by line analysis of every submission does not scale, and teaching X
times as many sections means that compromises will have to be made.

I am not worried about the top and middle thirds of the students, they largely
sail through on their own with pretty minimal guidance from me (it is an intro
course and many of them have strong backgrounds). The bottom third of the
class is new to programming though, so hopefully they will take more advantage
of lab and office hour time to solicit help.

~~~
tsumnia
The bottom third is where I hope to see improvement with the introduction of
typing exercises, lecture exercises (multiple choice/true-false/fill in the
blank style questions) and also I include YouTube videos of that week's
material. My logic is that like sports, you need to stretch and warmup before
doing a physical activity, so the same should be applied to a new concept. If
the student is still having trouble implementing the concepts on their own, by
having a prebuilt, functional version can help them see how it works.

Here's the current exercises for my Java 1 class:
[http://imgur.com/a/boc6h](http://imgur.com/a/boc6h)

So far, the students are responding favorably to the exercises and the only
fall out I've had are students that fail to show up or do any work. Grading
wise, the typing exercises are 10%, lecture exercises are 10% and the actual
programming assignments are 30%. Since the problems are a smaller chunk of
their overall grade, it alleviates the pressures of the 'all or nothing'
structure of the unit tests.

In my evaluations last semester, many loved the introduction of the YouTube
videos and I plan to ask them about the typing exercises this December.

I definitely agree on the personalized feedback portion though, that's why I
make the second class meeting only programming, no lecture. This way, they can
get their hands dirty with an experienced person to help them.

~~~
bobochan
Brilliant. About 75% of our class time is spent doing exercises in class with
me roaming about, or at least it would be if I could remember to stop talking
at certain points.

~~~
tsumnia
Smart! Before I let them loose during the 3 hour lab, I spend about 15 minutes
talking about the overall plan of a specific problem. For example, during
looping, they had to flip a coin 1,000,000 times and record the results. I
explained how Math.random() worked and how if they did "Math.random() > 0.5"
they could determine whether the coin was heads or tails.

Looking at my current scores: 9 have A's, 2 B's and sadly 1 F

~~~
bobochan
I wish that I could give out those grades (except for the F, obviously). One
of the drawbacks of our system is that we have to grade on a curve,
particularly the number of top grades that we give. The deans can give some
variation in that quota, but only in exceptional circumstances. It is hard
when I am teaching an elective and these are students that are specifically
choosing something very challenging when they could just as easily spend their
last semester coasting through.

I have never had to fail a student, but I have had a few violations of
academic integrity that had to be dealt with. One of the few upsides of
intensive grading is that I tend to remember specific errors, and a flag
always gets raised when I see the same error twice, regardless of how many
variable names were changed, etc.

------
manaskarekar
As an aside, the author, Philip Guo has some good posts on his blog:
[http://www.pgbovine.net/writings.htm](http://www.pgbovine.net/writings.htm)

------
agadabanka
excellent work! making students understand references/pointers has been my
biggest challenge. dynamic visualizations definitely help.

