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:

• CompSci 100 Feedback Summary
• CompSci 108 Feedback Summary
• CompSci 149s Feedback Summary

I’ve also attached the official numerical feedback summaries below.

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

Two other great submissions:

• Far Away From Java Code by Haoran Liu and Hanxiao Mao (lyrics)
• Algorithms and Data Structures Theme Song (adapted from the Pokemon theme song) by Jennifer Villa and friends (lyrics)

Check out the complete list.

Pretty much all of these songs are about how difficult the assignments in CS100 are. Should I be concerned?

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.

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.

Here pictures of everyone and more stuff about the competition.

The post-contest project we did was programming ants for the AI challenge. If you’re curious, click here to watch the 8 Ant AIs we had submitted duke it out in the Ultimate Ant Throwdown we had at the last day of class.

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:

1. 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.
2. 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.
3. 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”.
4. 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.
5. 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:

• Day 1: I began with the motivating question of the trinary computer. Is a trinary computer more powerful than a binary computer? I explained what I meant by computation and computational power, and then introduced the idea of cellular automata. I showed students a simple rule, I showed students a more complex rule, I asked students to predict the behavior of a relatively simple rule, and then I asked two groups of students to compete in building the most “interesting” automata possible.
• Day 2: Honestly I’m not quite sure what I did this day. Presumably we spent some more time playing around with cellular automata. Just goes to show you you should document your stuff as you do it.
• Day 3: I gave all the students an assignment…to build a cellular automata of at least 2+ colors or 4+ “looking”. Exactly what it did was completely up to them. To help them, we spent a day in the computer lab getting familiar with the Cellular automata code of NetLogo.

  This assignment was a really good move. I think it forced the students to engage with the material more carefully, which I was then able to use in later work. Also, several students took the opportunity to build some really cool automata. Three students came to me and asked if they could build a automata to multiply two numbers. In the process of that, they also built one to determine if one number was an equal divisor of the other.

• Day 4: We talked about Cellular automata doing genuine computation and I showed an example machine the squared an input number. Then I asked the students to attempt to simulate additional looking with a more colorful cellular automata. This took a while and some students struggled with it. Then I abstracted this into a general idea of proof by simulation. I showed a universal 16-color cellular automata and we talked about what it suggested how the computational power of cellular automata.
• Day 5: Introduced finite automata, and asked the students to build a few simple example ones. Then I explained the pumping lemma, and did 1 or two examples. When students had to use the pumping lemma on their own, they had some trouble with it.
• Day 6: Given the problems students had before, I went through a few more examples of the pumping lemma but people still seemed confused. I also briefly showed nondeterministic cellular automata and talked about regular expressions.
• Day 7: I finished my discussion of the pumping lemma by giving students a handout that stepped through my process in the pumping lemma. I introduced the specification of Turing machines, and then we walked through an example of Turing machine operation in JFLAP

  This was the last class for several of my students – they took the opportunity to try some other GHP math class. Most of my students stayed, plus I got a few extras. But I felt a little bad: some of the students said that they enjoyed the material but found the class was too challenging for them. Given the strong background of my students…I felt like that was a sign I was going a bit too fast and losing some of my students. If I do this class again I’ll definitely try to make stuff a little more explicit and move more carefully to ensure we don’t lose anyone before the big finish.

• Day 8: I presented students with a list of various Turing machines problems, sorted in difficulty from easier to harder. Each of them worked in pairs or small groups to solve problems of their choice
• Day 9: We implemented the Turing machines the students had designed in JFLAP. I went around a bit, helping students who were having some trouble implement their machines.
• Day 10: I asked 1 group of students to prove that Turing machines could be simulated by infinite automata and the other to prove the reverse. Both teams had success. I presented the idea that Turing machines could simulate modern computers. Then I discussed what this meant and introduced the Church-Turing thesis.
• Day 11: A discussion of incomputable problems.
• Day 12: Discussion of N vs. NP, including an introduction to non deterministic Turing machines and their relationship with verifiers
• Day 13: Discussion of the existence of NP complete problems, including a (very brief) synopsis of Cook’s theorem. I also showed how to provide Satisfiability was reducible to graph 3 coloring.
• Day 14: Some students spontaneously came up to me at the end and said they now felt confident trinary computers provided no additional power. Discussion with the whole class about how the course went

Files of interest:

1. DoesNotCompute1
2. Does not Compute 3
3. Does not Compute 4
4. Does Not Compute 5
5. Mike Solves a Pumping Lemma Problem
6. AutomataAssignment
7. The Epic Automata Showdown
8. Turing-Church Thesis

So, here’s what I did in my fractals class:

• Day 1: An introduction to the characteristics of fractals, a discussion of the Sierpinski gasket (including informal arguments for 0 area and infinite perimeter), an an introductory argument about the idea of fractional dimension using self similarity to compare what happens when you scale up a gasket, square, triangle, and cube. I felt like my 0 area argument could have used a little work, and I should have included an example of scaling up a triangle with an empty space in it into the mix. You can see my slides. I also introduced them to building fractals in Apophysis and we built an example gasket.
• Day 2: We played around with a program I had written to help understand Apophysis. The program allowed you to see the creation of Fractals as part of the action of a Multiple Reduction Copy Machine (a la Fractals in the Classroom which is my favorite fractal book). They could enter the same affine transformations they built in Apophysis and watch the individual reductions step by step. We also checked out the reductions that produced the Sierpinski Gasket and the Dragon Fractal. I went through the Gasket closely, trying to explain how the picture of the gasket itself was invariant under the 3 transformations even though individual points would move within the set. I think the students did get the idea that you could the “fractal” to be the set of points invariant under that particular transformation set. Then we spent the rest of the time entering individual fractals students like from Apophysis into the program and seeing how they were created. I would really like to expand this to make things even more clear with additions to the program, but obviously programming time is limited here at GHP. I also wish I had guided the students to think of the idea of invariant sets themselves somehow…
• Day 3: We introduced the Cantor set. I had the students do an exercise where they attempted to determine if an individual point was within the Cantor Set. I used that as a springboard to talk about trinary decimals, though I think this challenge was a bit hard for some students and they felt disengaged. The we talked about the fact that there are no contiguous points in the Cantor set. We talked about how the Cantor set can be thought of as having an invariant transform. Then, since we had a little time left at the end, we went though the Koch snowflake and talked about its area and perimeter.
• Day 4: I started the day asking the students to explain the idea of an invarient as a writing assignment. The results were so-so. Students seemed to get the idea of matrix transformations, but generally did not at least *say* the right stuff about what an invariant is. This class was where I really wanted to start talking about the idea of Fractal Dimension. My first goal was to get the students away from the idea of dimension as a number of parameters, so I thought I would talk about the idea of cardinalties of infinity. This was somewhat complicated by the fact that two of the other teachers includes cardinalties of infinity as one of their main topics. I didn’t want to step on anybody’s toes, so I opted to only do part of the story. What I chose to do was only talk about the fact that natural numbers have the same cardinality as the rationals, but not go into the real line. In retrospect, this was a dumb compromise: I should have either gone for it or not.

  I talked about about why dimension is important and why it’s not obvious. Then I had some fun with the students hamming it up with a funny extension of Hilbert’s Hotel. In this version, you’ve got a full hotel then one new person arrives. Then a bus pulls up with an infinite number of people. Then, there’s a crash on the highway and an infinite number of infinite busses show up (i.e. that rationals). Later, I heard a further extension where you can do the reals by talking about guests with infinitely long names and then there’s a secret guest the letter of who’s name is the opposite…blah blah blah. I didn’t do that one but its cool.

  After that, I showed them some steps for a space filling curve and asked them to try and draw a few steps (without revealing the result). You can see slides I used for this and the next lecture here.

• Day 5:Here’s where we got into the meat of Fractal dimension. I showed them space filling curves. Then I talked about why as simplistic space filling curve would not work. The finally I got to the business of self-similarity dimension, gave them the formula, and did a few examples in class.

  In retrospect, it seems obvious that I could have had the students work through a few examples of Fractal dimension as a worksheet or something. Or honestly, they could have derived the idea of self-similarity dimension themselves. Man! Now I am very regretful about this class. Next year!

• Day 6: I wanted to finish Fractal dimension off by introducing 2 new kinds of dimension – box counting and topological dimension. I had spent considerable amounts of time building an example for box counting with the coast of great Britian…but the short of it was it didn’t work. I think maybe it just didn’t have enough detail. I’m not sure it really helped folks anyway.

  I went though topological dimension using ball covering. My examples felt a little shaky initially, but eventually was able to explain how you need 3 overlaps to cover a plane and 4 to cover a volume (key point – where the 2/3 circles cross). But I think the students were lost and I didn’t have any exercises to help solidify it for them.

  I did manage to find a really cool set of fractal software, including a good one for box counting dimension. I showed the students but I think by this point they were a bit zoned out. Next time I’ll try and expand on it more, asking students to predict the boxes and figure out what it should mean.

• Day 7: After all our hard work, I wanted to give the students a little reward so I scheduled some computer time. I introduced them to Context Free and gave them a challenge to build certain shapes. You can see the details here. I think the idea was sound but the challenges did not moves slow enough – students needed a lot of help and really couldn’t get to explore context free.

  I think this was my greatest point of frustration with the fractal class. Things did look up once we got to Chaos.

• Day 8: Before this class, students had the opportunity to switch classes. I lost about 3…which surprised me considering how far under my game I felt. I collected student feedback and it was on the whole positive, with only a few students saying they felt lost. But it was significantly less positive than my Theory of Computation course.

  I introduced the idea of feedback systems, which in retrospect I think I ought to have gotten to on day one. Then I gave an example feedback system with ninjas. I then showed that system in excelFractalFeedbackSystems, and demonstrated how the feedback system produced chaotic behavior. Then I ended the class with some questions I had to students write up…many of them got it right and that improved my confidence that we were headed in the right direction. You can see my powerpoint and excel.

  I had a little extra time, so I went though the dough example and talked about shifting.

• Day 9: I had the bright idea to take the class into the computer lab where were they could explore. I also took the opportunity to move things into the complex plane. I showed students how model complex multiplication in excel (see my stuff here), and they saw that it produced a spiral when you did repeated applications of the same multiplication. I used that as a jumping off point to talk about how multiplying complex numbers is equivalent to multiplying magnitudes and adding arguments (Dennis showed me the easy proof of this…just convert the fractal to polar form using the pythag theorm, multiply, and check your trig identities). Then we explored a basic z^2 squaring system. We explored spiraling in and spiraling out, and I challenged the students to find something that made a circle.

  Dennis later showed me you could actually get even fancier with this. That unit circle contains both attractive and repulsive fixed points (0 and 1) and also cycles of arbitrary complexity. Rational powers of pi cycle, as I recall…but irrational ones never repeat. We didn’t get too into that in my class, but it is indeed awesome.

  Then we moved on to a slightly more complex system z^2 + c and saw a non-zero attractive point. We looked up the fixed point in wolfram alpha (though I think maybe we ought to have derived it by hand) That was where I left it.

• Day 10: On this day we took our explorations a bit further and I introduced the Julia and Mandelbrot sets. Using excel as my jumping off point, I talked about how some points converged and some points moved off to infinity. Then I showed the pictures and explained what was going on. I was ok with this but in retrospect I think we moved a little fast here and people lost sight of the relationship between the excel stuff we had done and the fractal pictures. I think a problem was that excel wasn’t sophisticated enough to actually render the julia sets so there was still this magical interplay where the secret number got entered into Chaos Pro and math went out the window.

  Although I very much liked what Excel was able to do for me, I really need a stronger base to let me students be smarter about their explorations and go all the way there.

  On this day I also noted that I could get a lot of mileage out of asking students to summarize the previous day’s work. Based on student’s faces, I think reviewing what we had discussed before really got them to recall and made people more engaged. I also think this was an easier question that was able to help struggling students feel more on top of things.

• Day 11: I had an activity where I asked students to pick a connected Julia set, characterize whether what happened to points in it (that is, cycle attractive fixed point etc) find the fixed points and classify them. This was where I discovered that students did not understand the relationship between the excel and the pretty pictures. People also continuously had trouble with c and z0. I think I should have built students up to this more by having them classify more stuff before this. But I think the idea of this activity was a good one, even if in actual instantiation is was a bit dicey.
• Day 12: Having gone as far as I wanted to with the Mandelbrot, I decided to go back to Chaos discuss bifurcations and maybe get to the Strange Attractors. Stage 1 was letting the students experiment with graphical iteration – something that I had avoided, but in retrospect felt a little silly about avoiding. Though I think that maybe this was what I should have done first, because once we hunkered down in 2-D reals things like fixed points, attractive fixed points, and other stuff students had been having trouble with became painfully obvious. My only regret is that because we did it last, it was sort of the anticlimax rather than the mysterious introduction.

  Anywoo, I explained graphical iteration and then we did a couple examples as a varied for the function ax(1 – x).

  I was able to use this software from the yale library which was extremely illuminating. In particular, I was able to understand and explain how the multiple concatenations of the functions could explain the existence 2 cycles and 4 cycles.

  We ended with the bifurcation diagram, and a discussion of the Feigenbaum point and constant.

• Day 13: We reviewed the meaning of the bifurcation diagram (again, I was amazed by how much folks forgot) and then I moved on to the 2 dimension system of the Henon map. I had written a program in R to show some details of the Henon Map – proving that it was chaotic and showing the bifurcation diagram for it. I also talked about how you could think of the Henon attractor as having 3 steps and showed the diagram from the book that suggests it is invariant.

  I also talked a bit about the Lorenz attractor.

• Day 14: As is somewhat GHP tradition, we talked about how the course went. I collected feedback (you can see the details here). And otherwise I talked about a few other fractal types they hadn’t seen, showed them a few fractals books if they wanted to explore on their own further, and let them play with fractal software for the rest of the class. Although there was not a need to cover a ton of content, I felt students got bored too fast – this day could have used something more

I’ll be presenting a paper about this at ICER 2011. The abstract says:

As CS becomes a larger field, many undergraduate programs are giving students greater freedom in the classes that make up their degree. This study looks at the process by which students within the CS major choose to specialize in some area. In this study we interviewed student advisors, graduated CS students, and students currently in the undergraduate process about their view of CS and how they make decisions. The interviews were analyzed with grounded theory approach. The analysis presents four forces that affect student decision making. One, students often use the amount they enjoy individual classes as a sign of how well they fit with a particular specialization. Two, students often do not research, so they select specializations based on misconceptions. Three, students often rely on the curriculum to protect against poor educational choices. Four, students usually do not have a personal vision for what they hope to do with a Computer Science degree.

You can read my version of the paper here.

Emboldened by the success of my very simple AI for Mario Brothers, my team opted to use a simple search-based algorithm for evaluating pandemic moves.  In our implementation, game-state objects represented the state of the game, and had the ability to return all the legal moves available in a particular state.  These various moves could generate new GameState objects that represented the state after the move was performed.  This let the AI avoid understanding the many effects of various moves – the AI could simply “simulate” the move and then evaluate the “goodness” of the resultant game state.

I think this a perfect example of the sort of solution that is quite obviously a dumb idea in retrospect.  To see why, consider the answer to these two questions:

1. How many moves are possible in any given game state?  Answer: approximately 10, as long as you eliminate certain high-branching moves.
2. How many moves do you have to look ahead to plausibly identify good states?  Answer: About 20-40.

If you pause to consider the magnitude of 10 quintillion for a second, I’m sure you can identify the problem with my team’s AI.  As a result, the search tree has to be pruned aggressively.  As a result of that, the AI adopts a short-term greedy stratgey that can’t win:

Pandemic AI Video from Michael Hewner on Vimeo.

In retrospect, I wish the instructor for this class has given us a more constrained problem for a final project.  Ninety percent of my team’s time was spent on details of implementing the game itself.  For a similar project difficulty, I could have implemented 4 more sophisticated AI approaches.

You can see the code here: http://code.google.com/p/pandemic/

The best part of the class was definitely mocking the stupid behavior of the wombats

Mark recently asked me to teach a guest lecture in his Media Computation data structures class.  The lecture was an introduction to the Simulation engine Greenfoot.  The goal was to introduce the idea of simulation, toss out a few key bits of terminology to prep students for later classes, and get students playing with the Greenfoot engine.  The course was 50 minutes for a class of 25 (though, in practice only about 15 or so showed).

Mark gave me some slides, I made a few modifications:

• I moved a few of the definitions to the end of the lecture.  Mark said the main goal was to get them playing with Greenfoot, so I figured I’d get to them if we had time.
• I turned a few question slides into concrete student activities.  Mark may have intended that…I adjusted them to my taste (mostly putting them in a multiple choice format so it was clear to students that would be accountable for the answers
• Cut a few slides, replaced some of the code heavy slides with live coding…once again could very much have been the intentio

What Went Well

Students responded well to the activities.  They also quickly warmed up to me, responded to my jokes, seemed to pay attention.  Reintroducing humor into my lessons has been a goal of mine, so I was happy with that.

What Went Poorly

We ran well over time, didn’t even finish the main coding activity (got to a chunk of it).  What made me feel especially dumb was that I wasn’t keeping close tabs like I should so I didn’t even adjust properly.  I was really glad I moved the less key slides to the end.

Part of the problem was I wasted time on the code reading activity.  The other issue was keeping the students in sync with me as we went through Greenfoot took a lot of time.  Very often I had to go back because somebody didn’t see how I added walls to the simulation or whatever.  In retrospect, I think I would have taken a page from Just in Time Teaching here…get the students ready to rock with a small tutorial assignment beforehand, so you can dive right to the interesting stuff in class.

But, excuses aside, letting class time get away from me was really bad and there’s really no reason it should have happened.

Tidbit

As is my custom, I had students fill out feedback forms.  This time though, I included a few content level questions on my forms:

1. Why do Computer Scientists think building simulations is a skill almost anyone could benefit from?
2. What is the difference between continuous and discrete simulations

I handed out these forms at the beginning of class.  I was curious to see if the students would answer them as they went or do it at the end.  The result was they did both, but I think either way it caused the students to pay more attention to what was going on in the definition part of the class.

Feedback

Student feedback summarized here.

My Slides

My slides.  I made it to slide 25.