So in my quality assurance course, I ask my students to form groups of 2-3 and build computerized versions of board games. I selected board games in particular because I knew board game logic was both understandable AND tricky enough that it could generally benefit from robust unit testing (which was what I was mainly asking them to practice for this project).
I was very happy with what my students produced. Every team worked well and reliably turned out code week after week – perhaps partly because they knew I was monitoring their github commits . These games are really quite complex…if you look at these videos I think you’ll see tons of detailed (and tricky to implement) logic.
And…lest you think I was slacking on the testing…each of these games has greater than 75% code coverage…not at all bad when you consider the complexity of the GUIs which are mostly untested.
I’m a big believer in student feedback. Even though students often can’t articulate the source of problems, going through and reflecting is an essential part of figuring out what I want to try going forward. So even in an environment like GHP where I’m not asked to formally collect evaluations, I always do. Of course, it really helps that at GHP in particular students are relentlessly positive. Seriously my worst review this summer was “not my favorite class by any means, but still good”. I wish that’s what my worst university eval looked like.
BUT, looking at the feedback (here and here), one thing that I am struck by is how much more satisfied by student feedback that is about course content and not about me. This is something that I think the Wicked Teacher of the West said first…but I can’t find the blog post now. When I student says “It’s a really great course” that of course makes me a little happy. But when a student says “I thought it was really neat how you could prove problems are incomputable by reducing them to other incomputable problems” that makes me think I did my job. It’s always about the student’s relationship with the content, not the student’s relationship with you.
I see that a lot more in my theory of computation course than I do in my fractals class – that makes me suspect I’m doing a better job in ToC.
Theory of Computation was different this year, I think because I didn’t have the same core of super-strong students who were really loving the course. There’s definitely a class culture that develops, and I’m not yet attuned enough to think seriously about how I can help its development. The course was still good, and I think I was able to smooth out some rough edges for some students. Remaining challenging however, is the issue of the two main proof techniques we do in class: the pumping lemma and incomputability proofs. If I teach this course again I’m gonna at least crack the pumping lemma.
Fractals was better this year. I found it less stressful, and I think the students learned more. Fractal dimension seemed like a big hit this time around, so I we can explore that a little more. We kicked things off with some very simple feedback functions and Chaos – I think that helped people get on board at the get go. I think affine transformations needs more exploration discussion and play. A little tricky without computers some times.
I wanted to have the color of my term-mode mode line switch, depending on whether I was in character mode or line mode. I’m not sure why this became an overwhelming desire of mine, but it did. Not really knowing anything about emacs font faces, themes, or anything I pulled up my debugger and started spelunking in color-theme-buffer-local. I discovered a mysterious function face-remap-add-relative designed to do exactly what I wanted – let me remap a particular part of a single buffers theme and then undo that mapping when finished.
A smarter person might have checked the emacs manual and saved himself a lot of time.
Here’s how it works:
;; set the modeline background color and save a "cookie" so the change can be undone
(setq old-term-color (face-remap-add-relative 'mode-line :background "dark goldenrod"))
;; undo that change later
(face-remap-remove-relative old-term-color)
Interestingly, I’m pretty sure this ability to change colors for a specific buffer is one of the new features of Emacs 24. Yay progress.
So I announced my defense today. It’ll be on November 2nd at 1pm in TSRB 132.
Here’s the abstract:
Computer Science is a complex field, and even experts do not always agree how the field should be defined. Though a moderate amount is known about how precollege students think about the field of CS, less is known about how CS majors’ conceptions of the field develop during the undergraduate curriculum. Given the difficulty of understanding CS, how do students make educational decisions like what electives or specializations to pursue?
This work presents a theory of student conceptions of CS, based on 37 interviews with students and student advisers and analyzed with a grounded theory approach. Students tend to have one of three main views about CS: CS as an academic discipline focused on the mathematical study of algorithms, CS as mostly about programming but also incorporating supporting subfields, and CS as a broad discipline with many different (programming and non-programming) subfields. I have also developed and piloted a survey instrument to determine how prevalent each kind of conception in the undergraduate population.
I also present a theory of student educational decisions in CS. Students do not usually have specific educational goals in CS and instead take an exploratory approach to their classes. Particularly enjoyable or unenjoyable classes cause them to narrow their educational focus. As a result, students do not reason very deeply about the CS content of their classes when they make educational decisions.
This work makes three main contributions: the theory of student conceptions, the theory of student educational decisions, and the preliminary survey instrument for evaluating student conceptions. This work has applications in CS curriculum design as well as for future research in the CS education community.
In my GHP Fractals class this summer, I opted to write my sample programs in R. I selected R because it has very nice graphing libraries and built-in complex numbers. Overall, I was pleased with R; it definitely let me built some incredibly straightforward fractal code. It’s not as fast or pretty as other choices might have been, but it highlighted the underlying math which was most important to me.
King's Dream Strange Attractor (parameters from Chaos In Wonderland)
.
You can see an example on the left, rendered by R. The source of this particular fractal comes from Clifford Pickover’s Chaos in Wonderland. The graph is made by repeatedly iterating a simple function of x and y based on sine and cosine.
You can see the code in R here:
a <- -0.966918
b <- 2.879879
c <- .765145
d <- .744728
pointsToPlot <- 100000
x <- .1
y <- .1
allXs = rep(0,pointsToPlot)
allYs = rep(0,pointsToPlot)
for(i in 1:pointsToPlot) {
newx <- sin(y*b) + c*sin(x*b)
newy <- sin(x*a) + d*sin(y*a)
x <- newx
y <- newy
allXs[i] <- x
allYs[i] <- y
}
plot(allXs, allYs, pch=".", col="red",
main="Strange Attractor: King's Dream")
Here’s a few more pretty pictures:
King’s Dream Strange Attractor from Chaos In Wonderland by Pickover
The henon attractor
A julia set
Fractal based on mobius transforms from Indra’s Pearls by Mumford Series and Wright
So Duke Spring 2012 is finished, and grades are in; it’s time for me to become an ordinary graduate student again. But before I do that, I think it’s reasonable to reflect just a bit on how the semester went.
All and all, I am happy but not ecstatic with how my first semester turned out. In general I think students enjoyed my classes and they learned a lot (and my course feedback reflects this). I was able to try out some techniques I thought would work well, and in general I had good success. Of course it also helped that my students were almost always enthusiastic and extremely conscientious.
One main thing I learned this semester is that I have to be a little bit more careful about how I manage my time outside the classroom. As a professor, there’s a lot I can do to help students and in the beginning it was really easy to put in a lot of extra hours. Not that I mind putting in extra hours for the students, but time away from relaxing and sleeping takes it’s toll. Towards the end of the semester, I just got exhausted and then I really couldn’t put in time sometimes when I really needed to.
Well, enough vagueness. Here’s what my students said in their written feedback, crudely summarized by me:
CS100 is a your basic CS2 course, providing an introduction to data structures, big O, and of course plenty of practice coding tricky problems. This course is a great favorite of mine to teach, mostly because of the office hours. It’s just fun to work with students who are just starting to get serious with Computer Science; they are still capable of having fun just getting the computer to output the right stuff.
For extra credit, we gave the student an opportunity to write a song about Computer Science. There were some super awesome submissions. One of my favorite lines is the refrain from this adaptation of Avril Lavigne’s Complicated (Noelle Suaifan):
Why’d you have to go and make Java so complicated?
I see the way you’re forgetting to import packages gets me frustrated
CompSci’s like this, you
And you code and your program implodes and takes forever to load
and you don’t insert that node and your code is the biggest mess
But promise me you’re never gonna switch your major to Art History
No, no, no
This is a post not really about what I did, but what 3 of the high-school students I worked with did. I met Gil and Claus in my automata class at GHP this summer. As part of the summer research project, they worked on developing their own kind of automata and ended up with something similar to a Neural Network. This fall, Gil, Claus, and Anirudh contacted me and proposed continuing that research but expanding the neural network connection for the Siemens Science Competition. Although I agreed to advise them where I could, this project was basically completely done start-to-finish by Gil, Claus, and Anirudh.
What eventually came out of this project was an attempt to build a Neural Network capable of optimizing the parameters of other neural networks. As the paper says:
The fundamental goal of this project is to create a backpropagation neural network that can determine the optimal training parameters to train another neural network with a different goal based on only characteristics of the training data. Such a neural network has the capability of improving the accuracy and speed of the training process for backpropagation networks used for any application.
In order to accomplish this Gil, Claus, and Anirudh researched neural networks, programmed their own network framework from scratch, and attempted to design a neural network that could help optimize other neural network parameters. Unfortunately the result they got was that the intermediate network wasn’t able to optimize properly. My opinion is their approach still has merit, and whether or not they get back to this particular project I hope they weren’t too disappointed with the negative result. This was a very cool project that required a great deal of both math and Computer Science to accomplish.
So one of the coolest traditions at in Duke is CS149s. Officially, it’s called the problem solving seminar. Unofficially, it’s weekly preparation for ACM ICPC competition. Students work hard in this course: every week they work on a problem set consisting of old ICPC competitions or TopCoder. It’s no small part from this class that Duke has gone to the ICPC international competition every year but 1 since 1994 (something like that anyway…don’t quote me on that).
Coming to Duke for the first time and never having competed in ICPC myself, being handed the reins of this course was a little bit scary. But lucky for me I had two incredible TAs – Kevin Kauffman and Siyang Chen. They helped me a lot in understanding what kind of preparation would be important and I like to think that I helped them with the pedagogical approach to teach it. I definitely changed the course – I made topics more explicit, I required a minimum number of problems each week, and I added a new post-contest project.
This year, Duke continued its streak by placing first in its region. My winning team was Jie Li, Yuqian Li, and Joe Keefer. I would like to claim some partial credit for that, but I’m pretty sure it’s strictly their own natural awesomeness. What I am especially happy about is that every Duke team managed to get 3 problems this year – including teams with non-majors and folks in intro CS. Everyone worked this year and I think it showed.
So I haven’t had much opportunity to post about my classes at Duke, but it has been very cool. I’ve found students at Duke to be very conscientious and smart, and my office hours have been very busy which is always fun. Of course there’s still plenty of the usual student foibles to contend with – but if students were virtuous and self-motivated all the time, I’d probably be out of a job.
This semester I’m co-instructing CS100 – a data structures course that occurs as the second course in a CS major but also accommodates a good number of non-majors. One of the perks of this job has been the opportunity to observe my co-instructor Owen Astrachan’s lectures. Owen definitely has one of the most refined lecture styles of anyone I’ve worked with – he’s got a whole repertoire of jokes, dances, and asides to keep students engaged. Not only do these little diversions keep interest in what can be a fairly lengthy 80 minute lecture, but I think it sets the tone of the course as much more relaxed and fun than what you get just looking at the webpage alone. I definitely have some work to do in getting myself to Owen’s level, lecture-wise.
But in my own lectures, I’ve been very self-conscious about designing each class myself. I take my cue from Owen on the content covered, but I have my own ideas about how to convey them best. My experience suggests that you’re much better off designing your own class and making your own mistakes. Standing up in front of the room holding some other professors notes (no matter how brilliant) is gonna guarantee a medicore class at best. If you design the lecture with a modicum of care yourself, even if it goes completely off the rails you’re likely to do better.
Of course, once you get out of that “off the rails” class, you might take a few hints from the experts and change your style appropriately.
But, after a semester of this, I think I’ve got a structure I’m happy with for this large lecture style class. Here’s how I do it:
Prep work. Because most of the lectures I teach are officially considered 160-person, lecture-style ‘recitations’ I’ve been able to get away with requiring students to do a 1-hour-ish prep for each class (which I always collect and check for participation). This is just as awesome as you’d expect. Sometimes I use this as a review of topics covered elsewhere I don’t have time to do in class, sometimes I use it give students an example of the kind of problem we’ll be doing more of in class, and sometimes it’s an introductory problem that I’ll build off in class.
As you sit down. I always give students something to do as they sit down and get ready for class, which I put on the powerpoint as they arrive. Students are somewhat blase about actually doing it (bad)…but I still like it insofar as it sets the expectation that you are already in your chairs and working the minute class begins.
Running slides that convey the learning objectives. I know a lot of older professors scoff at the idea of learning objects that you spec-out in class, but I love ‘em. Mostly, it focuses me when I’m planning the lecture to decide exactly what I want to cover, keeping in mind that if students learn more than 2-3 things in class it’s a miracle. But I also like making it explicit to the students what my plan is: we’re not just having a chat, if you have finished class and you don’t know 1 2 3 then at least you know what you ought to be looking up. My slides always look like “After class today you will be able to … 1 provide the definition of words a b c 2 code programming problems of type d 3 explain why the efficiency of e is f. Then at the appropriate points in the lecture I have sides that are like “At this point in the lecture you should 1 know the definitions of a b c *next up is* coding programming problems”.
Active learning regularly. Wherever there’s a concept that’s important and they won’t grasp it immediately, I have some on-slide multiple choice. If I feel like it would be better served in some other way, I’m also willing to have a worksheet students fill out in class. But usually multiple choice with hands works. Only trouble – not every student participates in the in-class multiple choice, and it’s often hard to know when we are done and we can begin discussion. I’m considering clickers for next semester.
In-class coding. For a class like this which coding is a large part of the final goal, I like to have at least 1 in class programming exercise that the students submit (Duke has a great system that makes submission very easy). For one thing, it breaks up the 60-minute-doldrums…I feel like I pretty much have to move out of the lecture mode and force students to work on a problem that takes at least 10 minutes without my direct intervention. For another, it clarifies how what we just talked about will relate to the actually nitty-gritty of their assignments tests and projects. The key difficulty here is difficulty…students are very willing to stare blankly at the screen, not asking for help for 10 minutes. I’ve had some luck with providing a range problems…implement 1 function where you only have to write 1 line in my pre-written code, another where you basically copy the first and change a couple things, and a third that’s a new variation.
So yeah, nothing fancy but it has been working well for me. If you’re curious in practice, here’s a video of my class on trees:
. These games are really quite complex…if you look at these videos I think you’ll see tons of detailed (and tricky to implement) logic.
