I looked at the HTML source, and I do redirect to Owlnet, where the COMP 202 page used to be. For Fall 2007, for example, I link to http://www.owlnet.rice.edu/~comp202/04-fall. Something must have happened to the website on Owlnet. I tried to log in, but the SSH password that I have for comp202 does not work anymore. Neither did my comp212 password.

When I logged in with mgricken, though, I was able to see that the comp202 page has been redirected to CLEAR at http://www.clear.rice.edu/comp202 regardless of what actual page was being requested from Owlnet. For example, http://www.owlnet.rice.edu/~comp202 was being redirected to http://www.clear.rice.edu/comp202, which is what I wanted, but http://www.owlnet.rice.edu/~comp202/04-fall was being redirected to the same place.

Once I had figured out how to log into CLEAR, I could see that the CLEAR page at http://www.clear.rice.edu/comp202 redirects to my page… And that’s why all roads lead to me :-)

As a simple fix, I just changed my links to point to the right pages on CLEAR, e.g. to http://www.clear.rice.edu/comp202/04-fall.

I think we should also edit the redirection, which IT must have put in place without talking to us, and make it work as it should. If we don’t, then links that we may have elsewhere and that point to Owlnet don’t working either.

The web is a rather transient place. There really is no point to put up an “under construction” sign, because any website always is under construction.

Update

Changing the .htaccess file to

should do the trick.

Update

IT set up the redirection according to my suggestion now. Requests for Owlnet pages are now redirected to the corresponding CLEAR page. Try it:

http://www.owlnet.rice.edu/~comp202/06-fall now redirects properly to http://www.clear.rice.edu/comp202/06-fall/.

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.

I’m also starting to look at the Java multi-stage programming project again, and I discovered that the OpenJDK people have added a Compiler Grammar project. This project is trying to replace the hand-coded parser for javac by a parser generated from an ANTLR grammar file. I haven’t fully checked how far this has progressed, but it is interesting. Modifying the grammar to allow annotations on statements and expressions should be easier than rewriting the interpreter by hand. It seems like there is a Java 5 grammar that integrates into javac, but of course there is no JSR 308 grammar, so I’d have to develop that first.

When I looked at ANTLR and the Compiler Grammar project, I also noticed an interesting IDE that has been built to make developing grammars easier: ANTLRWorks. It integrates a several checking tools and a debugger and looks tremendously helpful. For example, it can explain how a grammar is ambiguous. In my case, an annotation on a parenthetical expression could be parsed in two different ways, so I’ll have to be careful there.

ANTLR Ambiguous Path Visualization

On MacOS, I’m still struggling a bit to get the Compiler Grammar project and ANTLRWorks running. It seems like Compiler Grammar needs SoyLatte to work, and I have managed to build the Compiler Grammar javac from the command line, but when I try to run it inside ANTLRWorks, then it seems like it is using the default Apple Java version 1.6.0-dp, which doesn’t work. Maybe I’ll take a look at it on Windows first.

I also need to start thinking about the COMP 202 final exam, and about a lecture schedule and programming tasks for COMP 402 next semester.

% svn co https://drjava.svn.sourceforge.net/svnroot/drjava/trunk/drjava
svn: PROPFIND request failed on '/svnroot/drjava/!svn/vcc/default'
svn: PROPFIND of '/svnroot/drjava/!svn/vcc/default': SSL negotiation failed:
SSL error: decryption failed or bad record mac (https://drjava.svn.sourceforge.net)

Has anyone else encountered this? I can’t find any useful search results. However, when I do a checkout with http instead of https, it works (although I haven’t attempted to commit anything):

% svn co http://drjava.svn.sourceforge.net/svnroot/drjava/trunk/drjava
A    drjava/strip-license
A    drjava/LICENSE
...

Any advice is appreciated. I’m starting to think this is a SourceForge issue again, because I have been finding a handful of SSL issues.

Judging by my experience in the last few months and all the support requests (“We’ve been making some changes, try again *request closed*”), SourceForge has turned into a steaming bucket of excrement. Someone please flush.

I do have some new pictures from today’s lecture about parsing and the extended visitor pattern, though. Explaining the extended visitor pattern with all the type parameters is more difficult than I thought. I’ve decided to spend another day on it.

Update

It turned out that an upgrade to the latest OpenSSL and Subversion software on our side took care of the problem. I figured that would be a more sensible first attempt, rather than downgrading to an ancient version of OpenSSL, which is what SourceForge recommended.

There are profile pages that allow you to upload papers, presentations, declare research interests and describe your teaching experience, so I did that. The documents are uploaded as “iPaper”, and honestly, the preview still needs improvement. Right now, this part of the website is a bit annoying, as are most parts that use the AJAX “Web 2.0″ style of editing (not reloading the entire page).

So, right now I wouldn’t use Academia.edu to find material or people, but apparently it has a really high Google PageRank, and therefore a lot of weight for links. It seems like it has given my own website a considerable bump. I think it can be quite beneficial simply from the point of view of publicity.

The website also has an interesting feature that records what Google search terms lead web surfers to your Academia.edu profile. Here are the keywords that lead people to me — the actual things that they typed into Google:

• converting to a new temperature scale
• junit concurrent test
• conclusion on marine biology
• how to calculate the complexity of a given code using big o notation with exercise and solutions
• design pattern parser
• change in temperature calculations
• In java, show an example of a conversion from celsius to Fahrenheit temperature
• parsing design pattern

Apparently, temperature conversion is a very popular assignment, and my Temperature Calculator comes up quite often. I’m also amused by the fact that people type whole questions or requests into Google. “Google, please tell me why they do that. Thanks, bye.”

Additionally, Academia.edu has inspired me to collect all my papers, presentations and posters in one place, and I’ve created the Publications category. In that category, I have inserted my publications, both refereed and unrefereed, on the day they were made available. Because of that, the calendar of my blog now stretches back to 2003.

I decided to use a category on this blog mainly because now there is an RSS feed for my publications, and interested readers can easily subscribe and be notified of new material. On my non-blog work website, I have also added a publications page, both with long descriptions and without.

Finally, I’ve added an extra credit part to the COMP 202 schedule, worth 20 points which will be counted towards the midterm. It’s hard to believe that only five weeks are left in the semester. Two thirds are done.

Beethoven, of course, was fantastic. The cello solist, 25-year-old Alisa Wellerstein, was also very good, although I typically enjoy the entire orchestra more than solists. Therefore, I didn’t like Tchaikovsky as much as Beethoven’s 2nd Symphony. The first of the smaller pieces, “Adagio con Variationi” for cello and orchestra by Respighi was just amazing. Instantly I knew again why I am going to symphony concerts. Here, the interplay between the cello solo and the orchestra was perfect. Finally, Debussy’s “La Mer” was impressive as well.

In a few minutes I will hand out and proctor the COMP 202 midterm. Early today a student told me that he is sick and may not be able to take the exam. I said I will write a make-up exam and schedule a new time for him to take it. I spent the early afternoon writing a second midterm, but now it appears he feels better. If he does take the exam and I end up not needing the make-up exam¹, I will probably just use the questions for the final.

On Wednesday I’ll be pulling double duty when it comes to teaching, as Corky has asked me to sub in for him in his COMP 311 class.

1. He ended up not taking the exam, so I need the make-up exam. [back]

On Friday, September 5, I talked about generics and wildcards in my COMP 202 lecture. In the end, I unfortunately had a problem describing lower-bound wildcards. I couldn’t show the contravariant relationship. I corrected that on Monday. I noticed that there’s a big difference between being able to use wildcards and being able to clearly explain them.

Right after the COMP 617 seminar, Walid, Hashim, Jun, Cherif, Angela and I left for Abilene, TX to attend the Middle Earth Programming Languages Seminar. Walid did most of the seven-hour drive in both directions, but I somehow ended up doing most of the navigating, even though I was sitting in the left third-row seat. That sometimes made it hard to hear. Next time, if I navigate, I’ll want to sit closer. I also had some trouble with my allergies and my contacts during the trip — my eyes were getting really dry towards the end of the trip, but all in all the trip was fun. On Friday night, we watched a production of “Moonlight and Magnolias” at Abilene Christian University, and it was simply amazing. That’s one of the reasons why “Gone With The Wind” is in the title of this post.

The trip, and returning just before midnight on Saturday, did take a bit of energy out of me, though, so I had a hard time to get my part of COMP 202 homework #1 graded. Fortunately, the grading went well, thanks to our TA. On Monday, I corrected my mistake about wildcards from Friday, and then started talking about generic lists and algorithms on them.

We also had a lab on Monday so we could help the students with the GUI side of the Hangman game. Our TA was there, but I was a little disappointed about his knowledge of the assignment and Java. Dr. Wong and I plan to get him more involved and ultimately responsible for teaching the labs (as it should be), but this will be difficult.

On Wednesday, we finished talking about lists, and then started using some operations, like getting the first, removing the first, removing the rest, and removing the last x elements of a list to discuss how expensive these operations were. I didn’t quite introduce big-oh notation yet, but we generalized the number of operations to lists of length n. We still had a bit of an argument about which operations should count, so our counts were usually n, 2n, 3n, etc. It was a good discussion. Sadly, the video camera ran out of battery on this day.

On Friday I wanted to formalize this and introduce big-oh notation fully, but on Friday and Monday classes were canceled because of hurricane Ike — the other reason why “Gone With The Wind” is in the title, but more about that later. That made us lose two lectures and got the schedule in a bit of trouble. Today, I moved the exam and homework assignments around a bit. The university ruled that no assignments should be due this week, so I had to move homework #2 to next Monday. But in order to keep lectures and assignments together, I had to move them anyway.

In class today, only half of the students were there; I assume the others evacuated and hope they will be back soon. We finished talking about big-oh notation, and we cleared up why the constant factor in counting didn’t matter.

These entire two week seem like a blur, though, thanks to hurricane Ike. Starting late last Wednesday. we pretty much knew that this would be a close one. I went out to buy some more supplies on Wednesday night already. Some time on Thursday, a notice went out that classes are cancelled on Friday. After work on Thursday and early on Friday, I prepared my apartment for the storm: I taped cardboard covered in plastic bags to my windows again, a ghetto replacement for plywood. I know it couldn’t protect the window, but it should keep shards of glass out and give me a few more minutes to save valuable items. Then came the big wait.

The wind started getting pretty bad around 11 PM on Friday, but I went to bed at 2 AM, around the time “the Eyke” (the eye of Ike, as one newscaster accidentally called it) made landfall just east of Galveston, as a strong category 2 hurricane, just a couple of miles short of category 3. I woke up again at 2:30 AM when my UPSes started beeping. I had lost power. I quickly saved and and copied some files, then shut everything down. It was incredibly dark.

I woke up several times between 4 AM and 7 AM, when either bigger branches hit my apartment walls and windows, or when it sounded like there was hail. The hail probably scared me the most, because one of the meteorologists had said hail might indicate that there is a tornado nearby. A couple of times I was close to grabbing some blankets and moving into my bathroom, but I ended up sleeping through the entire hurricane in my bed.

When it had stopped raining hard in the early afternoon, I went outside and surveyed the damage. My apartment was not damaged, but there were lots of trees turned over. Some had fallen against other apartments or on cars. The fences around my apartment complex were gone. The Braes Bayou was a raging stream. I had expected something like I had seen after hurricane Rita, but this was much, much worse. Rita was nothing against this. And my power was still off. Rita just made it flicker.

Fortunately, I got my power and water back relatively quickly. There were still about 2 million people as of this morning who are without power. Biking or driving through Houston feels strange, because just one street separates apparent normality from chaos without power, water, gas, traffic lights, ATMs — everything we take for granted. It will take weeks before all Houstonians have their utilities restored, and probably months until the scars Ike made have been undone.

We then looked at how to make a Box<E>, a wrapper that could contain any kind of value, but you had to specify its type. Later we worked out on the board what a generic ILambda would look like, including an Equals example that compared two Integer values. Then we made another Equals<P> that could compare any two values of the same type, so we specified one of the type variables of ILambda<R,P>, but left the other one open.

The last thing I mentioned was that SpecialBox<Integer> was a subclass of Box<Integer> when SpecialBox<E> extends Box<E>, but I’ll have to revisit that again, because the important thing is that Box<Integer> is not a subtype of Box<Object> even though Integer is a subtype of Object.

We also ran into an interesting problem with boxing when we write Equals: p[0] and p[1] are Integers, so p[0]==p[1] does an identity comparison, not an integer equality test, so we had to do p[0].equals(p[1]), but that lead well to the exercise Equals<P>.

I also wasn’t sure about whether primitive types could be used in generics; I correctly said no, but I wasn’t sure, so I’ll reiterate that. I’m pretty happy with this lecture. We’ll see how well my students understood the concepts, because on Friday we’ll talk about upper and lower bounds and wildcards.

We came to realize that, depending on whether they use forward or backward accumulation, they all follow the same structure. In forward accumulation, they start with an initial value, perform some kind of operation with the initial value and the first of the list, then recur into the rest, using the result of the operation as initial value for the next level of recursion. In backward accumulation, they start with an initial value that is passed all the way to the end of the list. Then, for the empty list, that initial value is returned, and on the way out of the recursion, for each non-empty list, an operation is performed with the first of the list and the return value of the recursion that just finished, and the result is returned to the next level outward.

I then showed this in a more mathematical way, using a binary function f(x, y), and how forward accumulation yields f(f(f(f(i, l1), l2), l3), l4) for forward accumulation and f(l1, f(l2, f(l3, f(l4, i)))) for backward accumulation.

Unfortunately, I had written out our sample list from left to right, beginning with the empty list, as “empty-1-2-3″, instead of “1, 2, 3″, and that caused me to confuse fold left and fold right.

Another small problem occurred during the discussion of lambdas, the way we implement these different operations. The lecture notes provided code for an Add lambda. In fold left and fold right, the lambdas are binary; however, Add could process an arbitrary number of parameters. It would even add zero or one numbers. I wanted this to be exactly two — I should have previewed the lecture notes better, beyond the point of checking what code is there, but also precisely what it does. Fortunately, the Cons lambda was binary.

After we had discussed lambdas and worked out the code for FoldL and FoldR, we talked about how to do Reverse and Append using fold left and fold right, respectively. We arrived at the interesting result that the operations for both algorithms are the same!

The two things that differ between Reverse and Append is that they fold in different directions, and that they use different initial values (empy list and the list to append, respectively).

I thought the material was interesting today, and my motivation and the general arc through the lecture was good, but it was marred by the two mistakes, mostly confusing fold left and fold right.

I think the role-playing went well, although next time I should perhaps let the students do all of it. This time, I was the “visitor”, so a lot of what was going on was decided by me. On the other hand, this allowed me to mix the role-playing exercise with telling what the algorithms did.

For the list algorithms, we talked about reversing and appending. For appending, I could not find an algorithm that required a helper; my algorithm didn’t need a helper, but it wasn’t tail-recursive. We briefly talked about tail-recursion optimization.

In general, I’m quite happy with today’s lecture, although the video showed that I do have quite a few “uh”s as speech disfluencies, and that I could vary my pitch more. I still couldn’t get into the lab using my ID card, but I’ll check again on my way home.

Using index cards and role-playing to teach the visitor design pattern in lecture 2.

Besides some questions that had to do with getting “back into Java programming”, there was an interesting question about encapsulation, whether the visible and invisible states should be implemented as anonymous inner classes. I recommended that EmptyWord and NEWord be nested classes of the concrete word factory, and that AWordState, the visible state and the invisible state be nested inside NEWord, but I hadn’t considered implementing the latter two as anonymous inner classes. When I did that on the projector, it turned out that the visible state was an anonymous inner class defined inside toggleState() of the anonymous inner class for the invisible state. That was interesting, but perhaps made things more complicated.

I didn’t talk much about the algorithms run on word list and body part, so I ended up being a bit worried that not everyone knew what to do. I decided to revisit the encapsulation issue and the algorithms.

As everyone was leaving, there was a question about static as it applies to nested/inner classes. It took a little bit of effort, but I think I was able to explain how static nested classes do not have a reference to the enclosing class’ this, while non-static inner classes do, although I could not come up with a really compelling reason why non-static inner classes cannot have static members, except that static would not convey any advantage, because it could not be called in a static context anyway, but that would not have prevented Sun from just ignoring the static modifier.

I also found out that I’ll have a TA this semester, and I’m already very grateful for that already.

We went over the general information. Here I should have mentioned that the students can anonymously complain to Dr. Wong if they have a problem with me.

We did a quick review of IList and LRStruct and the design patterns involved. Then we already started with the lab material, talking about how to set up words. Composite, state and visitor with three cases came up. We will continue that in class.

On Friday, we might talk about the games they did at the end of COMP 201.

After a summer of waiting, I failed to consciously register one of the most anticipated things: the number of students. I think there were six or seven.

Also, I’m terribly disappointed by the clumsy interface of my video camera. I failed to record my first lecture on video.

But there’s a reason for that: In just an hour, I will be delivering the first lecture of the first course that I am teaching by myself, COMP 202 – Principles of Object-Oriented Programming II.

I’ve re-worked and re-ordered some of the past lectures, switched out a few assignments, and added a new one, Hangman Refactored. It uses the Janus principle and fits in really well after the Programming for Change lecture and the Temperature Calculator assignment. At least that’s what I think. We’ll see how it goes.

On Saturday, I went to a wonderful workshop that the School of Engineering set up for TAs. I was on their list because this year I get paid by the School of Engineering. The discussion of different learning styles prompted me to ask the students to fill out a Learning Styles Questionnaire.

During the last three or four days, I also improved the external process facility of DrJava a bit. Clearer error messages are now printed to the external process panes, there are ${and}, ${or}, ${not} and ${neq} (not equal) properties, and simple search-and-replace can be done using the ${replace.string;text="...";old="...";new="..."} property.

I then approached the NextGen and xajavac compiler addons for DrJava again. Fortunately, Dan had told me about javac argfiles, which elegantly solve the long-command-line problem. However, I discovered that some problems, like keeping together file names with spaces in them, reappear when printing to text files, even though I had solved them for the command line. I got around that by adding quoting options for file properties.

Now we have two working DrJava Addons (“djapps”) that integrate NextGen and xajavac into DrJava.

Okay now, I’m going to get ready for COMP 202. I hope my Rice ID card will finally let me into the room. Wish me luck.

In the last couple of years, though, we have added more and more windows: The predictive input dialogs to help you search or find Javadoc pages, the error dialog to collect and better display error messages while making them appear less critical, and now even the bottom panes and the debugger can be detached.

I handled most of this by creating a cooperative first-come-first-serve scheme of being modal. Every window that was trying to be modal, asked for modal status, but only one could have it. I considered moving making windows modal that were initially denied modal status, but left it there.

However, there were still other windows that could modally pop up, and those were real modal dialogs out of my control. In his bug report, [ 2040862 ] Modal dialog flicker: Project Properties/Increase Heap, Dan had one of my pseudo-modal dialogs (Project Properties) compete with a real modal dialog (Increase Heap).

Now I check whether the opposite window, the one that stole our focus, is a real modal dialog. If that is the case, we concede modalness. However, we install a listener that will make us modal again when the real modal dialog has been closed.

I have tried to simulate the problem with two windows competing, but I never quite succeeded, so I hope Dan or someone else can reproduce the problem and confirm that the issue has been fixed.

Shifting gears: I have been thinking and working a lot on the COMP 202 lecture notes, and website in general. I am taking over most of what was there from the previous year, but I am making a few changes. For example, I have decided to take more time for a few of the more difficult topics. I have also replaced two unpopular assignments with two assignments of mine, and I have replaced another assignment with one that I am more familiar with. I hope to maintain the level of teaching in general, but I also have to make sure I don’t completely overload myself. Better a little bit less but well done, than more with lots of confusion.

One thing I have to confess here, though: Please, please, no one edit HTML pages with Microsoft Word. Or some other very high-level editors. It pains me. I still edit HTML with emacs, and seeing all the superfluous tags hurts my eyes. Sometimes there is a separate tag around every letter of a word.

Just to do:

I guess the previous students never looked at the HTML source (why should they have?), so I’m not surprised there were no complaints from them. But honestly, the computers rendering the HTML should have thrown up.

End rant.