It features a list of externally visible features that need to be implemented, the product backlog. At the beginning of a sprint, which often lasts a month, the developers estimate which features they can implement during this sprint. Then they break the features down into tasks that need to be done.

Each task has a cost associated with it (basically the time it takes to implement, but it’s not really any real time span, rather something abstract, like jelly beans). The tasks are written on sticky notes.

During the daily Scrum stand-up meeting, all developers say what they did yesterday, what problems they had, and what they are going to do today. If they are out of tasks, they pick new sticky notes. If they are still working on the previous tasks, they re-estimate how much time is left for those tasks.

I really think that I should have taught COMP 402 using some kind of Scrum. A month-long sprint would have been too long, probably, and the class only met three times a week, but we probably could have done three week sprints?

Has anyone taught a software engineering/production programming class that used Scrum?

Thresher Course Evaluations Spring 2009 (lower is better, pdf)

Update

The Thresher incorrectly listed the Statistics (STAT), Computational and Applied Mathematics (CAAM), and Computer Science (COMP) departments as part of the School of Natural Science. At Rice, they are in the School of Engineering.

Also, I find it interesting that COMP is listed as #1 in the “Top 10 Hardest Majors” list.

Again, I feel like I have to make the comment that I didn’t write because I worked so much, not because there was nothing to write about. Blogging just has a very low priority for me right now.

Perhaps the biggest story is that Corky and I have published a paper together: ConcJUnit: Unit Testing for Concurrent Programs has been accepted at PPPJ 2009. The 7th International Conference on the Principles and Practice of Programming in Java will be held in Calgary, Canada at the end of August.

I’m quite excited about having this paper published, for two reasons: First, despite having worked with Corky for years now, this is actually the first paper we have co-authored. Second, I really only worked on the draft for four days before submitting it. On Monday night, April 20, I was at the Bill Bryson reading downtown, and when I was in line for autographs and checked my email, I saw a message from Corky that the PPPJ publication deadline had been postponed to Friday. He suggested that I submit something on unit testing concurrent programs.

Of course, right at that moment I thought “Four days? How am I supposed to do that?” and it seemed like a huge pain. But I decided I could pull a few things out of my thesis, enhance them a bit and give it a shot. Tuesday and Wednesday I experimented and added another feature to ConcJUnit, the concurrent unit testing framework I had developed, and Thursday and Friday I wrote the paper. It was rather short, a little under five pages, but I was happy with it. Friday night I almost got killed by a road-raged driver, but around 2 AM on Saturday night I submitted the paper (the submission deadlines are often on midnight at the international date line, i.e. 6 AM in Houston).

A few weeks passed while the paper was under review, but on June 5 we were notified that the paper had been accepted. I was in Finland at the time, so it was fortunate that the submission deadline of the camera-ready version had been postponed by a few weeks, so I didn’t have to work in Finland and could enjoy my vacation fully.

The other big story during the last half year was my work on Mint, a multi-stage extension of Java. This has been really interesting work. I was mostly involved in creating the implementation, creating sample programs and benchmarks, and writing some of the non-mathy parts of the paper. I’m still not nearly as quick thinking about many of the multi-stage constructs as some of the other researchers, but I’m getting there.

In the implementation, we started off with the OpenJDK compiler and added brackets (<| |> and <| { } |>), escapes (`) and the separable keyword. Brackets gets turned into a constructor call to a code object, and this code object contains an AST of the source inside the brackets. When a code object is run, we send the AST back into the compiler (at runtime!) and then call the created code.

This project felt a bit like a hack, like self-modifying code. It was great. I got a pretty good tour of the Java compiler too, more than I got to see with my xajavac experiments. We’re having some overhead from the compiler, but once that’s done we can speed up our code by factors of 5 to 20, depending on the benchmark. Explaining all these things in detail is too complicated here, so I’ll refer the interested reader to our technical report.

We first submitted a paper to GPCE 2009, but it got rejected. Initially I found this quite surprising, since I had so many strong collaborators, but it really came down to the wire with the submission deadline, and our paper still had many rough edges. Now we wrote the aforementioned technical report (which isn’t quite finished yet, actually, the appendix is still missing), and we submitted an improved version to POPL 2010. I dearly hope that the hard work of the last half year will pay off and reward us with a publication. I’ll probably continue to work on this for a bit, since I will probably be supported by Walid during the next year.

Something cool, although not significant from a professional point of view happened early this summer: Someone from VDM Verlag, a German academic publisher, contacted me and asked if I would like to publish my MS thesis as a book. It’s available on Amazon and other websites now. I have to stress that this is merely a republication of my MS thesis. There was no additional peer review beyond what my thesis committee did. As such, it should not be viewed as book or monograph, but it’s cool nonetheless:

Nothing much has happened with DrJava since the last post. We made a few bugfixes and improvements, and we’re planning to push out a new stable version soon.

I’ll close with some very nice reviews I got in my COMP 402 teaching evaluation:

Great course that introduces coding on a well establish code base. Completely different type of programming than that of lower level COMP classes. Taught a lot of practical programming techniques.

The course is good if you want to practice in Java. And it’s awesome that you can do some real work in the development of a real software.

Knows the code base well and good at helping students without doing the work for them. The few lecturers were interesting and well presented. Good professor for this class.

This class was more of independent study. The teacher was ready to help on completing a task whenever you asked him to. I learned a lot about production programming as a whole.

Mathias is a good instructor. He is very helpful when we have some trouble in work. And he always replies email very quickly. He is a nice guy. In addition, he is really great in DrJava.

Thank you for the kind words, and thanks to the School of Engineering, the department chair Joe Warren, and my advisor Corky for giving me this opportunity.

I ran into a diagram generator website a few days ago, and today it came in very handy to quickly create AST diagrams. I must say I really love yUML.me. You can design diagrams just by writing a link. For example, the diagram below is dynamically created from the link

http://yuml.me/diagram/class/[JCMethodInv o.foo1().foo2()]method->[JCFieldA x.foo2()],
[JCFieldA x.foo2()]selected->[JCMethodInv o.foo1()], [JCMethodInv o.foo1()]method->[JCFieldA x.foo1()],
[JCFieldA x.foo1()]selected->[JCIdent o], [JCFieldA x.foo2()]name->[Name foo2],
[JCFieldA x.foo1()]name->[Name foo1]

Anyway, back to work on secret things ;-)

The month of January was pretty thoroughly in the hands of COMP 402. In the past, the class called “Production Programming” was numbered COMP 312, and it was traditionally taught by my advisor, Corky, but this semester I am teaching it. I hope I’m doing an adequate job.

During the first four weeks, we discussed concurrency issues, SourceForge, Ant and Subversion, and we have also played around with some dynamic analysis tools, namely Clover for code coverage and YourKit as profiler. After the lecture phase was over, we started working in pairs in the lab, first writing some more unit tests, and then began finishing off the tasks on the lists I had prepared.

By now, we have finished the following tasks:

1. Test-Run Hourglass Freeze (Bug 2221819)
2. Focus Jumps to Interactions Pane (Bug 2153310)
3. Turn on “Hour Glass” When Indenting Code (Bug 687674)
4. displays internal representation of command-line args (2117750)
5. Empty java files cause junit test error
6. Debugging twice throws a DeadlockException (Bug 2106569)
7. Javadoc deletes directories (Bug 2498253)
8. Project Main Document Heuristics should not be hard-coded
9. Menu Item and Customizable Shortcut for Ctrl-D End of Stream
10. Imports should persist over breakpoints (Feature 1418853)
11. Allow “end of file” in System.in input (Feature 1470491)

We are still working on these tasks:

1. Project Main Document Heuristics should not be hard-coded
2. Default Imports for Interactions Pane
3. Change Double-Click Selection and Next/Prev Word

We still have a bunch of tasks on the list. The two most important tasks, though, are:

1. Network paths
2. New keyboard shortcut system

In general, most of these tasks don’t introduce big features. I have declared that this semester’s development is all under the name of stability.

Okay, it’s getting late. I think I will continue with the summary tomorrow.

We had an Othello tournament again, and it was great fun. Some of the games were really close, even though one strategy won all games.

Now I’m working on the lecture schedule and the homework for the COMP 402 – Production Programming class for next semester.