Well, now we have a far more interesting landscape for version control, particularly with the increased popularity of distributed version control. This is particularly appealing, because students can have a local repository that they work against, and when they are finished with an assignment then they can submit their work back to the course repository. There’s no reason why a centralized repository can’t do the same thing, but it’s an interesting new alternative.

I should say up front that I think students should become as familiar with version-control systems as they possibly can. That includes “fun” details like branching and merging. Having seen (and fixed) too many catastrophes in source-code repositories caused by people not understanding version-control, I want to help solve that problem. So, I am not afraid for students to have to dig into some of these details. (Of course their hand would be held initially!)

The main requirements I can think of are as follows:

• Some kind of directory-level authorization mechanism. Students shouldn’t be able to access each others’ work. Teachers should be able to access all students’ work.
• Ability to tag (or branch) a particular version. This would be an effective means of “turning in” an assignment: students just tag the version of their project that ought to be graded.
• Ability to incrementally provide code to students, e.g. the supporting code needed for each assignment, or if a student massively fails on an assignment, providing the reference implementation they can use going forward.

Right now I want to look at Subversion and Git; both are widely used, and both seem to offer many options in the above areas. Perhaps one will jump out as a clear leader, and I can see about deploying it for students to use in a project-class.

There are a variety of different water stones available, and I really didn’t know what to pick. Here is one website that has a selection of water stones. The Chosera stones looked really appealing, but the ones I wanted were out of stock, so I went ahead with the Shapton professional line of water stones. I chose a 1000-grit stone and a 5000-grit stone, which hopefully will be good to start with.

I also need to learn the proper technique for sharpening my knives, which is complicated slightly by the fact that Misono knives have more of a bevel on one side of the knife than on the other. This aids in making very accurate cuts. I enjoyed this feature of the knife, so I want to preserve that in my sharpening efforts; some people restore this to a 50/50 bevel, but that’s just not for me. Here is one website that describes how to sharpen knives; I will have to look for more when I get my water stones.

So, I can definitely recommend South too!

In general, it’s still very wise to try to change schemas as infrequently as possible, so I tend to batch up my changes, but South has almost completely removed my worries about making schema changes in my Django projects. It’s a great tool.

This page includes a LOT of database queries, almost to the point where I should be embarrassed, except for the fact that I hacked this thing together as quickly as possible, so actually I’m proud that it has as many features as it has. But for 130 students and around 15 assignments, the server-side code issues around 2000 queries, and you don’t need to be a genius to know that this just won’t be very fast.

But surprisingly enough, only about half the time is spent in database land; the rest of the time is spent rendering the Django template. I was quite surprised by this! I thought it would be much faster than that, but evidently not. There are three nested loops in the template, iterating over a large amount of data, so in retrospect it’s no surprise, but an hour ago I was sure that I needed to optimize the database interactions, not the template rendering. Now I see that the database code is only half of the problem.

All I did to find this was to add a couple of print statements around my view code to see how much time was actually spent in the database queries. I’m glad I did; I would have been completely befuddled, otherwise. It just goes to prove that old bit of software engineering wisdom, that if you try to optimize a system before you’ve actually profiled it, you probably won’t fix the real bottleneck.

I think I can fix this issue by creating a custom template-tag that will move some of the rendering into Python code, instead of being run in the template engine. The more I can incorporate into Python, the better off I’ll probably be. This may also help with the database side of things, because if I have clever template tags, then I can do less preparation with the data, and therefore fetch larger amounts of data from the back-end in one shot.

I implemented this feature for csman, a homework submission and grading system I have been implementing for the last couple of months, to use with the CS1, CS4, and CS11 classes that Mike Vanier and I teach. All of these classes have a similar homework-submission model, much like the model in real software projects: you write the code, and if it’s not good enough, you have to fix it.

Of course, grading redos is always a little annoying, so if you have a tool that lets you view a diff of the old submission and the new submission, it becomes very simple to see if the student actually fixed everything you told them to fix. (Sometimes they don’t. It’s very annoying when this happens.)

Anyway, it’s a cool little feature, to be able to see syntax-highlighted diff output on csman, but it definitely still needs a lot of work. The main issue is that frequently the files are too wide to display side-by-side, unless you happen to have a nice large monitor like I do. So, the problem really requires the effective use of scrollbars, both horizontal scrollbars to allow the diff-output to be visible in a smaller window, and also vertical scrollbars since otherwise those horizontal scrollbars are going to be waaayy at the bottom of your web page.

So, I have some work to do on that problem, but for now I’ll stick with what I have. It does the job, and one day when I learn more client-side JavaScript, maybe I’ll fix that kind of stuff up to be more snazzy.

Tri-tip steak is just great for making into sandwiches, because the grain goes along the long dimension of the cut, so you can cut it into thin pieces and get a totally tender and awesome piece of meat. The tri-tip is a triangle (surprise; equally surprising is that it’s also called a “triangle steak”) of meat at the base of the bottom sirloin primal, so it’s very flavorful but a little less tender than something higher up the cow. A lot of times it is marinated, then cooked relatively quickly on the grill, either to medium rare or medium. Then, slice it thin and serve it with baked beans, and that is a fantastic meal.

The sandwiches I wanted to create were going to go something like this:

• Ciabatta roll, preferably brushed with olive oil infused with garlic and rosemary then lightly toasted
• A light covering of mayo, perhaps the tiniest amount of mustard, and a good smear of goat cheese
• Some baby greens, probably arugula (a.k.a. “rocket”) for the peppery flavor
• A nice helping of thinly cut tri-tip

Given this was the goal, I decided on this marinade for my tri-tip:

• About a cup of red wine. I chose Caberenet Sauvignon since it’s a little fruitier and more mellow, and I wanted something a little tamer with the goat cheese and the arugula. (For a spicier result, Shiraz is the way to go!)
• About 2 tbsp of olive oil
• 5-6 cloves of garlic, peeled. Smash ‘em first, then chop them up. If you just chop them up, you don’t get as much flavor.
• 1.5 to 2 tsp of coarsely-ground black pepper. (I was more towards the 2tsp end…)
• About 1 tbsp of kosher salt
• The juice of about half a lemon

(Sorry; I usually don’t measure anymore unless I am baking!)

I threw all of this into a nice-sized bowl then whisked it up to combine.

I think a little dijon mustard would be fun to add to the marinade in the future, but I didn’t want to overdo it the first time.

I got out the target tri-tip steak, and using a paring knife, I stabbed the steak about every 2-3 inches, cutting across the grain, all over the roast. I wanted to make sure the marinade would penetrate the meat.

Then I threw the tri-tip into a zip-top bag, dumped in half the marinade on each side, then sealed it up. Then I moved the steak around, flexing it and massaging it a bit, to make sure the marinade would make it into all the holes I stabbed into the steak.

Then it was into the refrigerator overnight! In the morning I massaged the steak a bit more, then flipped it over and let it sit until tonight. 24 hours produced a good flavor, but 36 would probably be even better. Beyond that, I could see the flavor getting a bit overwhelming.

Tonight I built up a good size fire on the grill (I normally use charcoal), and spread it around the edges of the grill so I wouldn’t have the heat too direct. I also put some hickory chips on the fire to add a little smoky flavor to the steak as well. Once the grill was nice and hot (around 425 degrees F, according to my thermometer), I seared each side for about 5-10 minutes, then moved the steak to be in more indirect heat. (The thermometer started around 400 and dropped to about 365 by the end.) Once the internal temperature hit about 130°F (I was aiming for a result that was medium to medium-well, given the preferences of my guest; for medium-rare I would pull at 120), I pulled the tri-tip, covered it in foil, then let it rest for about 20 minutes. The meat coasted to about 145°F at the high point. I didn’t really try cutting into it until it was back down to around 130.

I have to say, the flavor is just unbelievably good. The wine and the garlic jump right out when you try a thin slice of the meat, and the pepper is a great underlying theme without being overwhelming. I find that lemon juice in my marinades “brightens” them up a bit, but you don’t want to actually taste it prominently; that was about where this one was, so I was quite happy.

I can’t wait to eat these sandwiches; they are going to be awesome! Maybe I will even share a bit of one with my guest…

The first surprise of the evening was that when the tuner sat down at the piano, the first thing he did was to pull out a little handheld PC, and start up a piece of software that he could use to help him to tune the piano. He would sit there and hit a note, and the program would display a little frequency plot, showing how the note actually sounded, versus how it was supposed to sound. I was blown away by this; the last time we had our piano tuned, such technology simply didn’t exist! The tuner would use his tuning forks to tune the piano, and that was that! But now there is a much easier way.

The guy had some great stories too. When asked if he wanted anything to drink, he replied, “I’d like a strawberry milkshake.” What?! He went on to explain that he had been called to tune a piano in Wayne Gretzky’s house (WAYNE GRETZKY), and a lady had come in and asked him if he’d like anything to drink. So he thought, why not?! “I’d like a strawberry milkshake.” And about ten minutes later, he had a strawberry milkshake. So, he explained, he always gives this answer now, just in case he actually gets one!

He told another great story about another client who played ragtime and honky tonk music, and called him up to get his piano tuned. A few days after he tuned the client’s piano, he got a phone call from the client: “I just can’t stand the sound of this piano!” So he went back out to the client, checked his work, and verified that everything was in fact properly tuned. Having ruled out the piano as the source of the issue, he asked the client what was wrong with the sound, and the client said, “It just doesn’t have the same ring that it used to have!” The tuner didn’t know exactly what the client meant, so the client finally pulled out an old vinyl record of some honky tonk music and played it for the tuner. When he heard the record, he immediately recognized that the piano in the recording was simply out of tune!

So, the tuner had a simple solution: he went through and knocked one wire of every note flat. The client was thrilled with the result. Of course, on the way out the door, the tuner told his client, “You probably shouldn’t waste your money on getting your piano accurately tuned anymore…

After these fantastic stories, I decided that the best thing to do was to get out of the tuner’s hair, and let him attend to his work. He made quick work of the piano as well, and did quite a good job. (He also recommended some good brands for when I finally upgrade to a grand or a baby-grand piano.) Of course, on the way out the door, the piano tuner had one last gem to share:

“Did you notice that the moon is full tonight?”
“I knew it was close, but I didn’t know it was tonight.”
“That explains your behavior. [pause] Good night!”

I could barely restrain my laughter!

This happens to be a 64-processor parallel computer, called the MOSAIC, that I programmed for CS20 during the third term of my sophomore year. It was a crazy little computer. The processors were connected up into a 2D mesh, and they could send messages left, right, up, or down. They only had about 64KB of memory per node, if I remember correctly, so you had to be pretty careful with your programming.

Communication and parallel computation were even crazier, because the communication channels between the processors were slack 1. That means you could send one message, and then the next send would block until the receiving processor actually read the message off of the channel. And the processors weren’t very bright, so it was very easy to have your program lock up the entire MOSAIC if you didn’t route your messages properly.

In CS20, the project was to simulate all of the components of a processor on this parallel computer. So, a few processors would be assigned to simulating ALUs, a few processors would handle stack operations, one would handle instruction decoding, a few would simulate heap memory, and so forth. It was such a fun project to work on, unlike anything I had ever done before, and I still remember it with great fondness to this day. Peter Hofstee was the teacher for CS20 that year, and I’m glad he came up with that crazy project.

I think I’m going to have to frame one of those boards and put it up on the wall!